["^ ","~:resource-id",["~:shadow.build.classpath/resource","goog/asserts/asserts.js"],"~:js","goog.loadModule(function(exports) {\n  \"use strict\";\n  goog.module(\"goog.asserts\");\n  goog.module.declareLegacyNamespace();\n  const DebugError = goog.require(\"goog.debug.Error\");\n  const NodeType = goog.require(\"goog.dom.NodeType\");\n  exports.ENABLE_ASSERTS = goog.define(\"goog.asserts.ENABLE_ASSERTS\", goog.DEBUG);\n  function AssertionError(messagePattern, messageArgs) {\n    DebugError.call(this, subs(messagePattern, messageArgs));\n    this.messagePattern = messagePattern;\n  }\n  goog.inherits(AssertionError, DebugError);\n  exports.AssertionError = AssertionError;\n  AssertionError.prototype.name = \"AssertionError\";\n  exports.DEFAULT_ERROR_HANDLER = function(e) {\n    throw e;\n  };\n  let errorHandler_ = exports.DEFAULT_ERROR_HANDLER;\n  function subs(pattern, subs) {\n    const splitParts = pattern.split(\"%s\");\n    let returnString = \"\";\n    const subLast = splitParts.length - 1;\n    for (let i = 0; i < subLast; i++) {\n      const sub = i < subs.length ? subs[i] : \"%s\";\n      returnString += splitParts[i] + sub;\n    }\n    return returnString + splitParts[subLast];\n  }\n  function doAssertFailure(defaultMessage, defaultArgs, givenMessage, givenArgs) {\n    let message = \"Assertion failed\";\n    let args;\n    if (givenMessage) {\n      message += \": \" + givenMessage;\n      args = givenArgs;\n    } else if (defaultMessage) {\n      message += \": \" + defaultMessage;\n      args = defaultArgs;\n    }\n    const e = new AssertionError(\"\" + message, args || []);\n    errorHandler_(e);\n  }\n  exports.setErrorHandler = function(errorHandler) {\n    if (exports.ENABLE_ASSERTS) {\n      errorHandler_ = errorHandler;\n    }\n  };\n  exports.assert = function(condition, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS && !condition) {\n      doAssertFailure(\"\", null, opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return condition;\n  };\n  exports.assertExists = function(value, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS && value == null) {\n      doAssertFailure(\"Expected to exist: %s.\", [value], opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return value;\n  };\n  exports.fail = function(opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS) {\n      errorHandler_(new AssertionError(\"Failure\" + (opt_message ? \": \" + opt_message : \"\"), Array.prototype.slice.call(arguments, 1)));\n    }\n  };\n  exports.assertNumber = function(value, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS && typeof value !== \"number\") {\n      doAssertFailure(\"Expected number but got %s: %s.\", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return value;\n  };\n  exports.assertString = function(value, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS && typeof value !== \"string\") {\n      doAssertFailure(\"Expected string but got %s: %s.\", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return value;\n  };\n  exports.assertFunction = function(value, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS && typeof value !== \"function\") {\n      doAssertFailure(\"Expected function but got %s: %s.\", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return value;\n  };\n  exports.assertObject = function(value, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS && !goog.isObject(value)) {\n      doAssertFailure(\"Expected object but got %s: %s.\", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return value;\n  };\n  exports.assertArray = function(value, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS && !Array.isArray(value)) {\n      doAssertFailure(\"Expected array but got %s: %s.\", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return value;\n  };\n  exports.assertBoolean = function(value, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS && typeof value !== \"boolean\") {\n      doAssertFailure(\"Expected boolean but got %s: %s.\", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return value;\n  };\n  exports.assertElement = function(value, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS && (!goog.isObject(value) || value.nodeType != NodeType.ELEMENT)) {\n      doAssertFailure(\"Expected Element but got %s: %s.\", [goog.typeOf(value), value], opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return value;\n  };\n  exports.assertInstanceof = function(value, type, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS && !(value instanceof type)) {\n      doAssertFailure(\"Expected instanceof %s but got %s.\", [getType(type), getType(value)], opt_message, Array.prototype.slice.call(arguments, 3));\n    }\n    return value;\n  };\n  exports.assertFinite = function(value, opt_message, var_args) {\n    if (exports.ENABLE_ASSERTS && (typeof value != \"number\" || !isFinite(value))) {\n      doAssertFailure(\"Expected %s to be a finite number but it is not.\", [value], opt_message, Array.prototype.slice.call(arguments, 2));\n    }\n    return value;\n  };\n  function getType(value) {\n    if (value instanceof Function) {\n      return value.displayName || value.name || \"unknown type name\";\n    } else if (value instanceof Object) {\n      return value.constructor.displayName || value.constructor.name || Object.prototype.toString.call(value);\n    } else {\n      return value === null ? \"null\" : typeof value;\n    }\n  }\n  return exports;\n});\n","~:source","/**\n * @license\n * Copyright The Closure Library Authors.\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/**\n * @fileoverview Utilities to check the preconditions, postconditions and\n * invariants runtime.\n *\n * Methods in this package are given special treatment by the compiler\n * for type-inference. For example, <code>goog.asserts.assert(foo)</code>\n * will make the compiler treat <code>foo</code> as non-nullable. Similarly,\n * <code>goog.asserts.assertNumber(foo)</code> informs the compiler about the\n * type of <code>foo</code>. Where applicable, such assertions are preferable to\n * casts by jsdoc with <code>@type</code>.\n *\n * The compiler has an option to disable asserts. So code like:\n * <code>\n * var x = goog.asserts.assert(foo());\n * goog.asserts.assert(bar());\n * </code>\n * will be transformed into:\n * <code>\n * var x = foo();\n * </code>\n * The compiler will leave in foo() (because its return value is used),\n * but it will remove bar() because it assumes it does not have side-effects.\n *\n * Additionally, note the compiler will consider the type to be \"tightened\" for\n * all statements <em>after</em> the assertion. For example:\n * <code>\n * const /** ?Object &#ast;/ value = foo();\n * goog.asserts.assert(value);\n * // \"value\" is of type {!Object} at this point.\n * </code>\n */\n\ngoog.module('goog.asserts');\ngoog.module.declareLegacyNamespace();\n\nconst DebugError = goog.require('goog.debug.Error');\nconst NodeType = goog.require('goog.dom.NodeType');\n\n\n// NOTE: this needs to be exported directly and referenced via the exports\n// object because unit tests stub it out.\n/**\n * @define {boolean} Whether to strip out asserts or to leave them in.\n */\nexports.ENABLE_ASSERTS = goog.define('goog.asserts.ENABLE_ASSERTS', goog.DEBUG);\n\n\n\n/**\n * Error object for failed assertions.\n * @param {string} messagePattern The pattern that was used to form message.\n * @param {!Array<*>} messageArgs The items to substitute into the pattern.\n * @constructor\n * @extends {DebugError}\n * @final\n */\nfunction AssertionError(messagePattern, messageArgs) {\n  DebugError.call(this, subs(messagePattern, messageArgs));\n\n  /**\n   * The message pattern used to format the error message. Error handlers can\n   * use this to uniquely identify the assertion.\n   * @type {string}\n   */\n  this.messagePattern = messagePattern;\n}\ngoog.inherits(AssertionError, DebugError);\nexports.AssertionError = AssertionError;\n\n/** @override @type {string} */\nAssertionError.prototype.name = 'AssertionError';\n\n\n/**\n * The default error handler.\n * @param {!AssertionError} e The exception to be handled.\n * @return {void}\n */\nexports.DEFAULT_ERROR_HANDLER = function(e) {\n  throw e;\n};\n\n\n/**\n * The handler responsible for throwing or logging assertion errors.\n * @type {function(!AssertionError)}\n */\nlet errorHandler_ = exports.DEFAULT_ERROR_HANDLER;\n\n\n/**\n * Does simple python-style string substitution.\n * subs(\"foo%s hot%s\", \"bar\", \"dog\") becomes \"foobar hotdog\".\n * @param {string} pattern The string containing the pattern.\n * @param {!Array<*>} subs The items to substitute into the pattern.\n * @return {string} A copy of `str` in which each occurrence of\n *     `%s` has been replaced an argument from `var_args`.\n */\nfunction subs(pattern, subs) {\n  const splitParts = pattern.split('%s');\n  let returnString = '';\n\n  // Replace up to the last split part. We are inserting in the\n  // positions between split parts.\n  const subLast = splitParts.length - 1;\n  for (let i = 0; i < subLast; i++) {\n    // keep unsupplied as '%s'\n    const sub = (i < subs.length) ? subs[i] : '%s';\n    returnString += splitParts[i] + sub;\n  }\n  return returnString + splitParts[subLast];\n}\n\n\n/**\n * Throws an exception with the given message and \"Assertion failed\" prefixed\n * onto it.\n * @param {string} defaultMessage The message to use if givenMessage is empty.\n * @param {?Array<*>} defaultArgs The substitution arguments for defaultMessage.\n * @param {string|undefined} givenMessage Message supplied by the caller.\n * @param {!Array<*>} givenArgs The substitution arguments for givenMessage.\n * @throws {AssertionError} When the value is not a number.\n */\nfunction doAssertFailure(defaultMessage, defaultArgs, givenMessage, givenArgs) {\n  let message = 'Assertion failed';\n  let args;\n  if (givenMessage) {\n    message += ': ' + givenMessage;\n    args = givenArgs;\n  } else if (defaultMessage) {\n    message += ': ' + defaultMessage;\n    args = defaultArgs;\n  }\n  // The '' + works around an Opera 10 bug in the unit tests. Without it,\n  // a stack trace is added to var message above. With this, a stack trace is\n  // not added until this line (it causes the extra garbage to be added after\n  // the assertion message instead of in the middle of it).\n  const e = new AssertionError('' + message, args || []);\n  errorHandler_(e);\n}\n\n\n/**\n * Sets a custom error handler that can be used to customize the behavior of\n * assertion failures, for example by turning all assertion failures into log\n * messages.\n * @param {function(!AssertionError)} errorHandler\n * @return {void}\n */\nexports.setErrorHandler = function(errorHandler) {\n  if (exports.ENABLE_ASSERTS) {\n    errorHandler_ = errorHandler;\n  }\n};\n\n\n/**\n * Checks if the condition evaluates to true if ENABLE_ASSERTS is\n * true.\n * @template T\n * @param {T} condition The condition to check.\n * @param {string=} opt_message Error message in case of failure.\n * @param {...*} var_args The items to substitute into the failure message.\n * @return {T} The value of the condition.\n * @throws {AssertionError} When the condition evaluates to false.\n * @closurePrimitive {asserts.truthy}\n */\nexports.assert = function(condition, opt_message, var_args) {\n  if (exports.ENABLE_ASSERTS && !condition) {\n    doAssertFailure(\n        '', null, opt_message, Array.prototype.slice.call(arguments, 2));\n  }\n  return condition;\n};\n\n\n/**\n * Checks if `value` is `null` or `undefined` if goog.asserts.ENABLE_ASSERTS is\n * true.\n *\n * @param {T} value The value to check.\n * @param {string=} opt_message Error message in case of failure.\n * @param {...*} var_args The items to substitute into the failure message.\n * @return {R} `value` with its type narrowed to exclude `null` and `undefined`.\n *\n * @template T\n * @template R :=\n *     mapunion(T, (V) =>\n *         cond(eq(V, 'null'),\n *             none(),\n *             cond(eq(V, 'undefined'),\n *                 none(),\n *                 V)))\n *  =:\n *\n * @throws {!AssertionError} When `value` is `null` or `undefined`.\n * @closurePrimitive {asserts.matchesReturn}\n */\nexports.assertExists = function(value, opt_message, var_args) {\n  if (exports.ENABLE_ASSERTS && value == null) {\n    doAssertFailure(\n        'Expected to exist: %s.', [value], opt_message,\n        Array.prototype.slice.call(arguments, 2));\n  }\n  return value;\n};\n\n\n/**\n * Fails if goog.asserts.ENABLE_ASSERTS is true. This function is useful in case\n * when we want to add a check in the unreachable area like switch-case\n * statement:\n *\n * <pre>\n *  switch(type) {\n *    case FOO: doSomething(); break;\n *    case BAR: doSomethingElse(); break;\n *    default: goog.asserts.fail('Unrecognized type: ' + type);\n *      // We have only 2 types - \"default:\" section is unreachable code.\n *  }\n * </pre>\n *\n * @param {string=} opt_message Error message in case of failure.\n * @param {...*} var_args The items to substitute into the failure message.\n * @return {void}\n * @throws {AssertionError} Failure.\n * @closurePrimitive {asserts.fail}\n */\nexports.fail = function(opt_message, var_args) {\n  if (exports.ENABLE_ASSERTS) {\n    errorHandler_(new AssertionError(\n        'Failure' + (opt_message ? ': ' + opt_message : ''),\n        Array.prototype.slice.call(arguments, 1)));\n  }\n};\n\n\n/**\n * Checks if the value is a number if goog.asserts.ENABLE_ASSERTS is true.\n * @param {*} value The value to check.\n * @param {string=} opt_message Error message in case of failure.\n * @param {...*} var_args The items to substitute into the failure message.\n * @return {number} The value, guaranteed to be a number when asserts enabled.\n * @throws {AssertionError} When the value is not a number.\n * @closurePrimitive {asserts.matchesReturn}\n */\nexports.assertNumber = function(value, opt_message, var_args) {\n  if (exports.ENABLE_ASSERTS && typeof value !== 'number') {\n    doAssertFailure(\n        'Expected number but got %s: %s.', [goog.typeOf(value), value],\n        opt_message, Array.prototype.slice.call(arguments, 2));\n  }\n  return /** @type {number} */ (value);\n};\n\n\n/**\n * Checks if the value is a string if goog.asserts.ENABLE_ASSERTS is true.\n * @param {*} value The value to check.\n * @param {string=} opt_message Error message in case of failure.\n * @param {...*} var_args The items to substitute into the failure message.\n * @return {string} The value, guaranteed to be a string when asserts enabled.\n * @throws {AssertionError} When the value is not a string.\n * @closurePrimitive {asserts.matchesReturn}\n */\nexports.assertString = function(value, opt_message, var_args) {\n  if (exports.ENABLE_ASSERTS && typeof value !== 'string') {\n    doAssertFailure(\n        'Expected string but got %s: %s.', [goog.typeOf(value), value],\n        opt_message, Array.prototype.slice.call(arguments, 2));\n  }\n  return /** @type {string} */ (value);\n};\n\n\n/**\n * Checks if the value is a function if goog.asserts.ENABLE_ASSERTS is true.\n * @param {*} value The value to check.\n * @param {string=} opt_message Error message in case of failure.\n * @param {...*} var_args The items to substitute into the failure message.\n * @return {!Function} The value, guaranteed to be a function when asserts\n *     enabled.\n * @throws {AssertionError} When the value is not a function.\n * @closurePrimitive {asserts.matchesReturn}\n */\nexports.assertFunction = function(value, opt_message, var_args) {\n  if (exports.ENABLE_ASSERTS && typeof value !== 'function') {\n    doAssertFailure(\n        'Expected function but got %s: %s.', [goog.typeOf(value), value],\n        opt_message, Array.prototype.slice.call(arguments, 2));\n  }\n  return /** @type {!Function} */ (value);\n};\n\n\n/**\n * Checks if the value is an Object if goog.asserts.ENABLE_ASSERTS is true.\n * @param {*} value The value to check.\n * @param {string=} opt_message Error message in case of failure.\n * @param {...*} var_args The items to substitute into the failure message.\n * @return {!Object} The value, guaranteed to be a non-null object.\n * @throws {AssertionError} When the value is not an object.\n * @closurePrimitive {asserts.matchesReturn}\n */\nexports.assertObject = function(value, opt_message, var_args) {\n  if (exports.ENABLE_ASSERTS && !goog.isObject(value)) {\n    doAssertFailure(\n        'Expected object but got %s: %s.', [goog.typeOf(value), value],\n        opt_message, Array.prototype.slice.call(arguments, 2));\n  }\n  return /** @type {!Object} */ (value);\n};\n\n\n/**\n * Checks if the value is an Array if ENABLE_ASSERTS is true.\n * @param {*} value The value to check.\n * @param {string=} opt_message Error message in case of failure.\n * @param {...*} var_args The items to substitute into the failure message.\n * @return {!Array<?>} The value, guaranteed to be a non-null array.\n * @throws {AssertionError} When the value is not an array.\n * @closurePrimitive {asserts.matchesReturn}\n */\nexports.assertArray = function(value, opt_message, var_args) {\n  if (exports.ENABLE_ASSERTS && !Array.isArray(value)) {\n    doAssertFailure(\n        'Expected array but got %s: %s.', [goog.typeOf(value), value],\n        opt_message, Array.prototype.slice.call(arguments, 2));\n  }\n  return /** @type {!Array<?>} */ (value);\n};\n\n\n/**\n * Checks if the value is a boolean if goog.asserts.ENABLE_ASSERTS is true.\n * @param {*} value The value to check.\n * @param {string=} opt_message Error message in case of failure.\n * @param {...*} var_args The items to substitute into the failure message.\n * @return {boolean} The value, guaranteed to be a boolean when asserts are\n *     enabled.\n * @throws {AssertionError} When the value is not a boolean.\n * @closurePrimitive {asserts.matchesReturn}\n */\nexports.assertBoolean = function(value, opt_message, var_args) {\n  if (exports.ENABLE_ASSERTS && typeof value !== 'boolean') {\n    doAssertFailure(\n        'Expected boolean but got %s: %s.', [goog.typeOf(value), value],\n        opt_message, Array.prototype.slice.call(arguments, 2));\n  }\n  return /** @type {boolean} */ (value);\n};\n\n\n/**\n * Checks if the value is a DOM Element if goog.asserts.ENABLE_ASSERTS is true.\n * @param {*} value The value to check.\n * @param {string=} opt_message Error message in case of failure.\n * @param {...*} var_args The items to substitute into the failure message.\n * @return {!Element} The value, likely to be a DOM Element when asserts are\n *     enabled.\n * @throws {AssertionError} When the value is not an Element.\n * @closurePrimitive {asserts.matchesReturn}\n * @deprecated Use goog.asserts.dom.assertIsElement instead.\n */\nexports.assertElement = function(value, opt_message, var_args) {\n  if (exports.ENABLE_ASSERTS &&\n      (!goog.isObject(value) ||\n       /** @type {!Node} */ (value).nodeType != NodeType.ELEMENT)) {\n    doAssertFailure(\n        'Expected Element but got %s: %s.', [goog.typeOf(value), value],\n        opt_message, Array.prototype.slice.call(arguments, 2));\n  }\n  return /** @type {!Element} */ (value);\n};\n\n\n/**\n * Checks if the value is an instance of the user-defined type if\n * goog.asserts.ENABLE_ASSERTS is true.\n *\n * The compiler may tighten the type returned by this function.\n *\n * Do not use this to ensure a value is an HTMLElement or a subclass! Cross-\n * document DOM inherits from separate - though identical - browser classes, and\n * such a check will unexpectedly fail. Please use the methods in\n * goog.asserts.dom for these purposes.\n *\n * @param {?} value The value to check.\n * @param {function(new: T, ...)} type A user-defined constructor.\n * @param {string=} opt_message Error message in case of failure.\n * @param {...*} var_args The items to substitute into the failure message.\n * @throws {AssertionError} When the value is not an instance of\n *     type.\n * @return {T}\n * @template T\n * @closurePrimitive {asserts.matchesReturn}\n */\nexports.assertInstanceof = function(value, type, opt_message, var_args) {\n  if (exports.ENABLE_ASSERTS && !(value instanceof type)) {\n    doAssertFailure(\n        'Expected instanceof %s but got %s.', [getType(type), getType(value)],\n        opt_message, Array.prototype.slice.call(arguments, 3));\n  }\n  return value;\n};\n\n\n/**\n * Checks whether the value is a finite number, if ENABLE_ASSERTS\n * is true.\n *\n * @param {*} value The value to check.\n * @param {string=} opt_message Error message in case of failure.\n * @param {...*} var_args The items to substitute into the failure message.\n * @throws {AssertionError} When the value is not a number, or is\n *     a non-finite number such as NaN, Infinity or -Infinity.\n * @return {number} The value initially passed in.\n */\nexports.assertFinite = function(value, opt_message, var_args) {\n  if (exports.ENABLE_ASSERTS &&\n      (typeof value != 'number' || !isFinite(value))) {\n    doAssertFailure(\n        'Expected %s to be a finite number but it is not.', [value],\n        opt_message, Array.prototype.slice.call(arguments, 2));\n  }\n  return /** @type {number} */ (value);\n};\n\n/**\n * Returns the type of a value. If a constructor is passed, and a suitable\n * string cannot be found, 'unknown type name' will be returned.\n * @param {*} value A constructor, object, or primitive.\n * @return {string} The best display name for the value, or 'unknown type name'.\n */\nfunction getType(value) {\n  if (value instanceof Function) {\n    return value.displayName || value.name || 'unknown type name';\n  } else if (value instanceof Object) {\n    return /** @type {string} */ (value.constructor.displayName) ||\n        value.constructor.name || Object.prototype.toString.call(value);\n  } else {\n    return value === null ? 'null' : typeof value;\n  }\n}\n","~:compiled-at",1684858197812,"~:source-map-json","{\n\"version\":3,\n\"file\":\"goog.asserts.asserts.js\",\n\"lineCount\":129,\n\"mappings\":\"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\",\n\"sources\":[\"goog/asserts/asserts.js\"],\n\"sourcesContent\":[\"/**\\n * @license\\n * Copyright The Closure Library Authors.\\n * SPDX-License-Identifier: Apache-2.0\\n */\\n\\n/**\\n * @fileoverview Utilities to check the preconditions, postconditions and\\n * invariants runtime.\\n *\\n * Methods in this package are given special treatment by the compiler\\n * for type-inference. For example, <code>goog.asserts.assert(foo)</code>\\n * will make the compiler treat <code>foo</code> as non-nullable. Similarly,\\n * <code>goog.asserts.assertNumber(foo)</code> informs the compiler about the\\n * type of <code>foo</code>. Where applicable, such assertions are preferable to\\n * casts by jsdoc with <code>@type</code>.\\n *\\n * The compiler has an option to disable asserts. So code like:\\n * <code>\\n * var x = goog.asserts.assert(foo());\\n * goog.asserts.assert(bar());\\n * </code>\\n * will be transformed into:\\n * <code>\\n * var x = foo();\\n * </code>\\n * The compiler will leave in foo() (because its return value is used),\\n * but it will remove bar() because it assumes it does not have side-effects.\\n *\\n * Additionally, note the compiler will consider the type to be \\\"tightened\\\" for\\n * all statements <em>after</em> the assertion. For example:\\n * <code>\\n * const /** ?Object &#ast;/ value = foo();\\n * goog.asserts.assert(value);\\n * // \\\"value\\\" is of type {!Object} at this point.\\n * </code>\\n */\\n\\ngoog.module('goog.asserts');\\ngoog.module.declareLegacyNamespace();\\n\\nconst DebugError = goog.require('goog.debug.Error');\\nconst NodeType = goog.require('goog.dom.NodeType');\\n\\n\\n// NOTE: this needs to be exported directly and referenced via the exports\\n// object because unit tests stub it out.\\n/**\\n * @define {boolean} Whether to strip out asserts or to leave them in.\\n */\\nexports.ENABLE_ASSERTS = goog.define('goog.asserts.ENABLE_ASSERTS', goog.DEBUG);\\n\\n\\n\\n/**\\n * Error object for failed assertions.\\n * @param {string} messagePattern The pattern that was used to form message.\\n * @param {!Array<*>} messageArgs The items to substitute into the pattern.\\n * @constructor\\n * @extends {DebugError}\\n * @final\\n */\\nfunction AssertionError(messagePattern, messageArgs) {\\n  DebugError.call(this, subs(messagePattern, messageArgs));\\n\\n  /**\\n   * The message pattern used to format the error message. Error handlers can\\n   * use this to uniquely identify the assertion.\\n   * @type {string}\\n   */\\n  this.messagePattern = messagePattern;\\n}\\ngoog.inherits(AssertionError, DebugError);\\nexports.AssertionError = AssertionError;\\n\\n/** @override @type {string} */\\nAssertionError.prototype.name = 'AssertionError';\\n\\n\\n/**\\n * The default error handler.\\n * @param {!AssertionError} e The exception to be handled.\\n * @return {void}\\n */\\nexports.DEFAULT_ERROR_HANDLER = function(e) {\\n  throw e;\\n};\\n\\n\\n/**\\n * The handler responsible for throwing or logging assertion errors.\\n * @type {function(!AssertionError)}\\n */\\nlet errorHandler_ = exports.DEFAULT_ERROR_HANDLER;\\n\\n\\n/**\\n * Does simple python-style string substitution.\\n * subs(\\\"foo%s hot%s\\\", \\\"bar\\\", \\\"dog\\\") becomes \\\"foobar hotdog\\\".\\n * @param {string} pattern The string containing the pattern.\\n * @param {!Array<*>} subs The items to substitute into the pattern.\\n * @return {string} A copy of `str` in which each occurrence of\\n *     `%s` has been replaced an argument from `var_args`.\\n */\\nfunction subs(pattern, subs) {\\n  const splitParts = pattern.split('%s');\\n  let returnString = '';\\n\\n  // Replace up to the last split part. We are inserting in the\\n  // positions between split parts.\\n  const subLast = splitParts.length - 1;\\n  for (let i = 0; i < subLast; i++) {\\n    // keep unsupplied as '%s'\\n    const sub = (i < subs.length) ? subs[i] : '%s';\\n    returnString += splitParts[i] + sub;\\n  }\\n  return returnString + splitParts[subLast];\\n}\\n\\n\\n/**\\n * Throws an exception with the given message and \\\"Assertion failed\\\" prefixed\\n * onto it.\\n * @param {string} defaultMessage The message to use if givenMessage is empty.\\n * @param {?Array<*>} defaultArgs The substitution arguments for defaultMessage.\\n * @param {string|undefined} givenMessage Message supplied by the caller.\\n * @param {!Array<*>} givenArgs The substitution arguments for givenMessage.\\n * @throws {AssertionError} When the value is not a number.\\n */\\nfunction doAssertFailure(defaultMessage, defaultArgs, givenMessage, givenArgs) {\\n  let message = 'Assertion failed';\\n  let args;\\n  if (givenMessage) {\\n    message += ': ' + givenMessage;\\n    args = givenArgs;\\n  } else if (defaultMessage) {\\n    message += ': ' + defaultMessage;\\n    args = defaultArgs;\\n  }\\n  // The '' + works around an Opera 10 bug in the unit tests. Without it,\\n  // a stack trace is added to var message above. With this, a stack trace is\\n  // not added until this line (it causes the extra garbage to be added after\\n  // the assertion message instead of in the middle of it).\\n  const e = new AssertionError('' + message, args || []);\\n  errorHandler_(e);\\n}\\n\\n\\n/**\\n * Sets a custom error handler that can be used to customize the behavior of\\n * assertion failures, for example by turning all assertion failures into log\\n * messages.\\n * @param {function(!AssertionError)} errorHandler\\n * @return {void}\\n */\\nexports.setErrorHandler = function(errorHandler) {\\n  if (exports.ENABLE_ASSERTS) {\\n    errorHandler_ = errorHandler;\\n  }\\n};\\n\\n\\n/**\\n * Checks if the condition evaluates to true if ENABLE_ASSERTS is\\n * true.\\n * @template T\\n * @param {T} condition The condition to check.\\n * @param {string=} opt_message Error message in case of failure.\\n * @param {...*} var_args The items to substitute into the failure message.\\n * @return {T} The value of the condition.\\n * @throws {AssertionError} When the condition evaluates to false.\\n * @closurePrimitive {asserts.truthy}\\n */\\nexports.assert = function(condition, opt_message, var_args) {\\n  if (exports.ENABLE_ASSERTS && !condition) {\\n    doAssertFailure(\\n        '', null, opt_message, Array.prototype.slice.call(arguments, 2));\\n  }\\n  return condition;\\n};\\n\\n\\n/**\\n * Checks if `value` is `null` or `undefined` if goog.asserts.ENABLE_ASSERTS is\\n * true.\\n *\\n * @param {T} value The value to check.\\n * @param {string=} opt_message Error message in case of failure.\\n * @param {...*} var_args The items to substitute into the failure message.\\n * @return {R} `value` with its type narrowed to exclude `null` and `undefined`.\\n *\\n * @template T\\n * @template R :=\\n *     mapunion(T, (V) =>\\n *         cond(eq(V, 'null'),\\n *             none(),\\n *             cond(eq(V, 'undefined'),\\n *                 none(),\\n *                 V)))\\n *  =:\\n *\\n * @throws {!AssertionError} When `value` is `null` or `undefined`.\\n * @closurePrimitive {asserts.matchesReturn}\\n */\\nexports.assertExists = function(value, opt_message, var_args) {\\n  if (exports.ENABLE_ASSERTS && value == null) {\\n    doAssertFailure(\\n        'Expected to exist: %s.', [value], opt_message,\\n        Array.prototype.slice.call(arguments, 2));\\n  }\\n  return value;\\n};\\n\\n\\n/**\\n * Fails if goog.asserts.ENABLE_ASSERTS is true. This function is useful in case\\n * when we want to add a check in the unreachable area like switch-case\\n * statement:\\n *\\n * <pre>\\n *  switch(type) {\\n *    case FOO: doSomething(); break;\\n *    case BAR: doSomethingElse(); break;\\n *    default: goog.asserts.fail('Unrecognized type: ' + type);\\n *      // We have only 2 types - \\\"default:\\\" section is unreachable code.\\n *  }\\n * </pre>\\n *\\n * @param {string=} opt_message Error message in case of failure.\\n * @param {...*} var_args The items to substitute into the failure message.\\n * @return {void}\\n * @throws {AssertionError} Failure.\\n * @closurePrimitive {asserts.fail}\\n */\\nexports.fail = function(opt_message, var_args) {\\n  if (exports.ENABLE_ASSERTS) {\\n    errorHandler_(new AssertionError(\\n        'Failure' + (opt_message ? ': ' + opt_message : ''),\\n        Array.prototype.slice.call(arguments, 1)));\\n  }\\n};\\n\\n\\n/**\\n * Checks if the value is a number if goog.asserts.ENABLE_ASSERTS is true.\\n * @param {*} value The value to check.\\n * @param {string=} opt_message Error message in case of failure.\\n * @param {...*} var_args The items to substitute into the failure message.\\n * @return {number} The value, guaranteed to be a number when asserts enabled.\\n * @throws {AssertionError} When the value is not a number.\\n * @closurePrimitive {asserts.matchesReturn}\\n */\\nexports.assertNumber = function(value, opt_message, var_args) {\\n  if (exports.ENABLE_ASSERTS && typeof value !== 'number') {\\n    doAssertFailure(\\n        'Expected number but got %s: %s.', [goog.typeOf(value), value],\\n        opt_message, Array.prototype.slice.call(arguments, 2));\\n  }\\n  return /** @type {number} */ (value);\\n};\\n\\n\\n/**\\n * Checks if the value is a string if goog.asserts.ENABLE_ASSERTS is true.\\n * @param {*} value The value to check.\\n * @param {string=} opt_message Error message in case of failure.\\n * @param {...*} var_args The items to substitute into the failure message.\\n * @return {string} The value, guaranteed to be a string when asserts enabled.\\n * @throws {AssertionError} When the value is not a string.\\n * @closurePrimitive {asserts.matchesReturn}\\n */\\nexports.assertString = function(value, opt_message, var_args) {\\n  if (exports.ENABLE_ASSERTS && typeof value !== 'string') {\\n    doAssertFailure(\\n        'Expected string but got %s: %s.', [goog.typeOf(value), value],\\n        opt_message, Array.prototype.slice.call(arguments, 2));\\n  }\\n  return /** @type {string} */ (value);\\n};\\n\\n\\n/**\\n * Checks if the value is a function if goog.asserts.ENABLE_ASSERTS is true.\\n * @param {*} value The value to check.\\n * @param {string=} opt_message Error message in case of failure.\\n * @param {...*} var_args The items to substitute into the failure message.\\n * @return {!Function} The value, guaranteed to be a function when asserts\\n *     enabled.\\n * @throws {AssertionError} When the value is not a function.\\n * @closurePrimitive {asserts.matchesReturn}\\n */\\nexports.assertFunction = function(value, opt_message, var_args) {\\n  if (exports.ENABLE_ASSERTS && typeof value !== 'function') {\\n    doAssertFailure(\\n        'Expected function but got %s: %s.', [goog.typeOf(value), value],\\n        opt_message, Array.prototype.slice.call(arguments, 2));\\n  }\\n  return /** @type {!Function} */ (value);\\n};\\n\\n\\n/**\\n * Checks if the value is an Object if goog.asserts.ENABLE_ASSERTS is true.\\n * @param {*} value The value to check.\\n * @param {string=} opt_message Error message in case of failure.\\n * @param {...*} var_args The items to substitute into the failure message.\\n * @return {!Object} The value, guaranteed to be a non-null object.\\n * @throws {AssertionError} When the value is not an object.\\n * @closurePrimitive {asserts.matchesReturn}\\n */\\nexports.assertObject = function(value, opt_message, var_args) {\\n  if (exports.ENABLE_ASSERTS && !goog.isObject(value)) {\\n    doAssertFailure(\\n        'Expected object but got %s: %s.', [goog.typeOf(value), value],\\n        opt_message, Array.prototype.slice.call(arguments, 2));\\n  }\\n  return /** @type {!Object} */ (value);\\n};\\n\\n\\n/**\\n * Checks if the value is an Array if ENABLE_ASSERTS is true.\\n * @param {*} value The value to check.\\n * @param {string=} opt_message Error message in case of failure.\\n * @param {...*} var_args The items to substitute into the failure message.\\n * @return {!Array<?>} The value, guaranteed to be a non-null array.\\n * @throws {AssertionError} When the value is not an array.\\n * @closurePrimitive {asserts.matchesReturn}\\n */\\nexports.assertArray = function(value, opt_message, var_args) {\\n  if (exports.ENABLE_ASSERTS && !Array.isArray(value)) {\\n    doAssertFailure(\\n        'Expected array but got %s: %s.', [goog.typeOf(value), value],\\n        opt_message, Array.prototype.slice.call(arguments, 2));\\n  }\\n  return /** @type {!Array<?>} */ (value);\\n};\\n\\n\\n/**\\n * Checks if the value is a boolean if goog.asserts.ENABLE_ASSERTS is true.\\n * @param {*} value The value to check.\\n * @param {string=} opt_message Error message in case of failure.\\n * @param {...*} var_args The items to substitute into the failure message.\\n * @return {boolean} The value, guaranteed to be a boolean when asserts are\\n *     enabled.\\n * @throws {AssertionError} When the value is not a boolean.\\n * @closurePrimitive {asserts.matchesReturn}\\n */\\nexports.assertBoolean = function(value, opt_message, var_args) {\\n  if (exports.ENABLE_ASSERTS && typeof value !== 'boolean') {\\n    doAssertFailure(\\n        'Expected boolean but got %s: %s.', [goog.typeOf(value), value],\\n        opt_message, Array.prototype.slice.call(arguments, 2));\\n  }\\n  return /** @type {boolean} */ (value);\\n};\\n\\n\\n/**\\n * Checks if the value is a DOM Element if goog.asserts.ENABLE_ASSERTS is true.\\n * @param {*} value The value to check.\\n * @param {string=} opt_message Error message in case of failure.\\n * @param {...*} var_args The items to substitute into the failure message.\\n * @return {!Element} The value, likely to be a DOM Element when asserts are\\n *     enabled.\\n * @throws {AssertionError} When the value is not an Element.\\n * @closurePrimitive {asserts.matchesReturn}\\n * @deprecated Use goog.asserts.dom.assertIsElement instead.\\n */\\nexports.assertElement = function(value, opt_message, var_args) {\\n  if (exports.ENABLE_ASSERTS &&\\n      (!goog.isObject(value) ||\\n       /** @type {!Node} */ (value).nodeType != NodeType.ELEMENT)) {\\n    doAssertFailure(\\n        'Expected Element but got %s: %s.', [goog.typeOf(value), value],\\n        opt_message, Array.prototype.slice.call(arguments, 2));\\n  }\\n  return /** @type {!Element} */ (value);\\n};\\n\\n\\n/**\\n * Checks if the value is an instance of the user-defined type if\\n * goog.asserts.ENABLE_ASSERTS is true.\\n *\\n * The compiler may tighten the type returned by this function.\\n *\\n * Do not use this to ensure a value is an HTMLElement or a subclass! Cross-\\n * document DOM inherits from separate - though identical - browser classes, and\\n * such a check will unexpectedly fail. Please use the methods in\\n * goog.asserts.dom for these purposes.\\n *\\n * @param {?} value The value to check.\\n * @param {function(new: T, ...)} type A user-defined constructor.\\n * @param {string=} opt_message Error message in case of failure.\\n * @param {...*} var_args The items to substitute into the failure message.\\n * @throws {AssertionError} When the value is not an instance of\\n *     type.\\n * @return {T}\\n * @template T\\n * @closurePrimitive {asserts.matchesReturn}\\n */\\nexports.assertInstanceof = function(value, type, opt_message, var_args) {\\n  if (exports.ENABLE_ASSERTS && !(value instanceof type)) {\\n    doAssertFailure(\\n        'Expected instanceof %s but got %s.', [getType(type), getType(value)],\\n        opt_message, Array.prototype.slice.call(arguments, 3));\\n  }\\n  return value;\\n};\\n\\n\\n/**\\n * Checks whether the value is a finite number, if ENABLE_ASSERTS\\n * is true.\\n *\\n * @param {*} value The value to check.\\n * @param {string=} opt_message Error message in case of failure.\\n * @param {...*} var_args The items to substitute into the failure message.\\n * @throws {AssertionError} When the value is not a number, or is\\n *     a non-finite number such as NaN, Infinity or -Infinity.\\n * @return {number} The value initially passed in.\\n */\\nexports.assertFinite = function(value, opt_message, var_args) {\\n  if (exports.ENABLE_ASSERTS &&\\n      (typeof value != 'number' || !isFinite(value))) {\\n    doAssertFailure(\\n        'Expected %s to be a finite number but it is not.', [value],\\n        opt_message, Array.prototype.slice.call(arguments, 2));\\n  }\\n  return /** @type {number} */ (value);\\n};\\n\\n/**\\n * Returns the type of a value. If a constructor is passed, and a suitable\\n * string cannot be found, 'unknown type name' will be returned.\\n * @param {*} value A constructor, object, or primitive.\\n * @return {string} The best display name for the value, or 'unknown type name'.\\n */\\nfunction getType(value) {\\n  if (value instanceof Function) {\\n    return value.displayName || value.name || 'unknown type name';\\n  } else if (value instanceof Object) {\\n    return /** @type {string} */ (value.constructor.displayName) ||\\n        value.constructor.name || Object.prototype.toString.call(value);\\n  } else {\\n    return value === null ? 'null' : typeof value;\\n  }\\n}\\n\"],\n\"names\":[\"goog\",\"module\",\"declareLegacyNamespace\",\"DebugError\",\"require\",\"NodeType\",\"exports\",\"ENABLE_ASSERTS\",\"define\",\"DEBUG\",\"AssertionError\",\"messagePattern\",\"messageArgs\",\"call\",\"subs\",\"inherits\",\"prototype\",\"name\",\"DEFAULT_ERROR_HANDLER\",\"exports.DEFAULT_ERROR_HANDLER\",\"e\",\"errorHandler_\",\"pattern\",\"splitParts\",\"split\",\"returnString\",\"subLast\",\"length\",\"i\",\"sub\",\"doAssertFailure\",\"defaultMessage\",\"defaultArgs\",\"givenMessage\",\"givenArgs\",\"message\",\"args\",\"setErrorHandler\",\"exports.setErrorHandler\",\"errorHandler\",\"assert\",\"exports.assert\",\"condition\",\"opt_message\",\"var_args\",\"Array\",\"slice\",\"arguments\",\"assertExists\",\"exports.assertExists\",\"value\",\"fail\",\"exports.fail\",\"assertNumber\",\"exports.assertNumber\",\"typeOf\",\"assertString\",\"exports.assertString\",\"assertFunction\",\"exports.assertFunction\",\"assertObject\",\"exports.assertObject\",\"isObject\",\"assertArray\",\"exports.assertArray\",\"isArray\",\"assertBoolean\",\"exports.assertBoolean\",\"assertElement\",\"exports.assertElement\",\"nodeType\",\"ELEMENT\",\"assertInstanceof\",\"exports.assertInstanceof\",\"type\",\"getType\",\"assertFinite\",\"exports.assertFinite\",\"isFinite\",\"Function\",\"displayName\",\"Object\",\"constructor\",\"toString\"]\n}\n"]