{"version":3,"sources":["node_modules/@firebase/util/dist/index.esm2017.js","node_modules/@firebase/component/dist/esm/index.esm2017.js","node_modules/@firebase/logger/dist/esm/index.esm2017.js","node_modules/@firebase/app/dist/esm/index.esm2017.js","node_modules/idb/build/wrap-idb-value.js","node_modules/idb/build/index.js"],"sourcesContent":["/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * @fileoverview Firebase constants.  Some of these (@defines) can be overridden at compile-time.\r\n */\nconst CONSTANTS = {\n  /**\r\n   * @define {boolean} Whether this is the client Node.js SDK.\r\n   */\n  NODE_CLIENT: false,\n  /**\r\n   * @define {boolean} Whether this is the Admin Node.js SDK.\r\n   */\n  NODE_ADMIN: false,\n  /**\r\n   * Firebase SDK Version\r\n   */\n  SDK_VERSION: '${JSCORE_VERSION}'\n};\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Throws an error if the provided assertion is falsy\r\n */\nconst assert = function (assertion, message) {\n  if (!assertion) {\n    throw assertionError(message);\n  }\n};\n/**\r\n * Returns an Error object suitable for throwing.\r\n */\nconst assertionError = function (message) {\n  return new Error('Firebase Database (' + CONSTANTS.SDK_VERSION + ') INTERNAL ASSERT FAILED: ' + message);\n};\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nconst stringToByteArray$1 = function (str) {\n  // TODO(user): Use native implementations if/when available\n  const out = [];\n  let p = 0;\n  for (let i = 0; i < str.length; i++) {\n    let c = str.charCodeAt(i);\n    if (c < 128) {\n      out[p++] = c;\n    } else if (c < 2048) {\n      out[p++] = c >> 6 | 192;\n      out[p++] = c & 63 | 128;\n    } else if ((c & 0xfc00) === 0xd800 && i + 1 < str.length && (str.charCodeAt(i + 1) & 0xfc00) === 0xdc00) {\n      // Surrogate Pair\n      c = 0x10000 + ((c & 0x03ff) << 10) + (str.charCodeAt(++i) & 0x03ff);\n      out[p++] = c >> 18 | 240;\n      out[p++] = c >> 12 & 63 | 128;\n      out[p++] = c >> 6 & 63 | 128;\n      out[p++] = c & 63 | 128;\n    } else {\n      out[p++] = c >> 12 | 224;\n      out[p++] = c >> 6 & 63 | 128;\n      out[p++] = c & 63 | 128;\n    }\n  }\n  return out;\n};\n/**\r\n * Turns an array of numbers into the string given by the concatenation of the\r\n * characters to which the numbers correspond.\r\n * @param bytes Array of numbers representing characters.\r\n * @return Stringification of the array.\r\n */\nconst byteArrayToString = function (bytes) {\n  // TODO(user): Use native implementations if/when available\n  const out = [];\n  let pos = 0,\n    c = 0;\n  while (pos < bytes.length) {\n    const c1 = bytes[pos++];\n    if (c1 < 128) {\n      out[c++] = String.fromCharCode(c1);\n    } else if (c1 > 191 && c1 < 224) {\n      const c2 = bytes[pos++];\n      out[c++] = String.fromCharCode((c1 & 31) << 6 | c2 & 63);\n    } else if (c1 > 239 && c1 < 365) {\n      // Surrogate Pair\n      const c2 = bytes[pos++];\n      const c3 = bytes[pos++];\n      const c4 = bytes[pos++];\n      const u = ((c1 & 7) << 18 | (c2 & 63) << 12 | (c3 & 63) << 6 | c4 & 63) - 0x10000;\n      out[c++] = String.fromCharCode(0xd800 + (u >> 10));\n      out[c++] = String.fromCharCode(0xdc00 + (u & 1023));\n    } else {\n      const c2 = bytes[pos++];\n      const c3 = bytes[pos++];\n      out[c++] = String.fromCharCode((c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63);\n    }\n  }\n  return out.join('');\n};\n// We define it as an object literal instead of a class because a class compiled down to es5 can't\n// be treeshaked. https://github.com/rollup/rollup/issues/1691\n// Static lookup maps, lazily populated by init_()\nconst base64 = {\n  /**\r\n   * Maps bytes to characters.\r\n   */\n  byteToCharMap_: null,\n  /**\r\n   * Maps characters to bytes.\r\n   */\n  charToByteMap_: null,\n  /**\r\n   * Maps bytes to websafe characters.\r\n   * @private\r\n   */\n  byteToCharMapWebSafe_: null,\n  /**\r\n   * Maps websafe characters to bytes.\r\n   * @private\r\n   */\n  charToByteMapWebSafe_: null,\n  /**\r\n   * Our default alphabet, shared between\r\n   * ENCODED_VALS and ENCODED_VALS_WEBSAFE\r\n   */\n  ENCODED_VALS_BASE: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + 'abcdefghijklmnopqrstuvwxyz' + '0123456789',\n  /**\r\n   * Our default alphabet. Value 64 (=) is special; it means \"nothing.\"\r\n   */\n  get ENCODED_VALS() {\n    return this.ENCODED_VALS_BASE + '+/=';\n  },\n  /**\r\n   * Our websafe alphabet.\r\n   */\n  get ENCODED_VALS_WEBSAFE() {\n    return this.ENCODED_VALS_BASE + '-_.';\n  },\n  /**\r\n   * Whether this browser supports the atob and btoa functions. This extension\r\n   * started at Mozilla but is now implemented by many browsers. We use the\r\n   * ASSUME_* variables to avoid pulling in the full useragent detection library\r\n   * but still allowing the standard per-browser compilations.\r\n   *\r\n   */\n  HAS_NATIVE_SUPPORT: typeof atob === 'function',\n  /**\r\n   * Base64-encode an array of bytes.\r\n   *\r\n   * @param input An array of bytes (numbers with\r\n   *     value in [0, 255]) to encode.\r\n   * @param webSafe Boolean indicating we should use the\r\n   *     alternative alphabet.\r\n   * @return The base64 encoded string.\r\n   */\n  encodeByteArray(input, webSafe) {\n    if (!Array.isArray(input)) {\n      throw Error('encodeByteArray takes an array as a parameter');\n    }\n    this.init_();\n    const byteToCharMap = webSafe ? this.byteToCharMapWebSafe_ : this.byteToCharMap_;\n    const output = [];\n    for (let i = 0; i < input.length; i += 3) {\n      const byte1 = input[i];\n      const haveByte2 = i + 1 < input.length;\n      const byte2 = haveByte2 ? input[i + 1] : 0;\n      const haveByte3 = i + 2 < input.length;\n      const byte3 = haveByte3 ? input[i + 2] : 0;\n      const outByte1 = byte1 >> 2;\n      const outByte2 = (byte1 & 0x03) << 4 | byte2 >> 4;\n      let outByte3 = (byte2 & 0x0f) << 2 | byte3 >> 6;\n      let outByte4 = byte3 & 0x3f;\n      if (!haveByte3) {\n        outByte4 = 64;\n        if (!haveByte2) {\n          outByte3 = 64;\n        }\n      }\n      output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);\n    }\n    return output.join('');\n  },\n  /**\r\n   * Base64-encode a string.\r\n   *\r\n   * @param input A string to encode.\r\n   * @param webSafe If true, we should use the\r\n   *     alternative alphabet.\r\n   * @return The base64 encoded string.\r\n   */\n  encodeString(input, webSafe) {\n    // Shortcut for Mozilla browsers that implement\n    // a native base64 encoder in the form of \"btoa/atob\"\n    if (this.HAS_NATIVE_SUPPORT && !webSafe) {\n      return btoa(input);\n    }\n    return this.encodeByteArray(stringToByteArray$1(input), webSafe);\n  },\n  /**\r\n   * Base64-decode a string.\r\n   *\r\n   * @param input to decode.\r\n   * @param webSafe True if we should use the\r\n   *     alternative alphabet.\r\n   * @return string representing the decoded value.\r\n   */\n  decodeString(input, webSafe) {\n    // Shortcut for Mozilla browsers that implement\n    // a native base64 encoder in the form of \"btoa/atob\"\n    if (this.HAS_NATIVE_SUPPORT && !webSafe) {\n      return atob(input);\n    }\n    return byteArrayToString(this.decodeStringToByteArray(input, webSafe));\n  },\n  /**\r\n   * Base64-decode a string.\r\n   *\r\n   * In base-64 decoding, groups of four characters are converted into three\r\n   * bytes.  If the encoder did not apply padding, the input length may not\r\n   * be a multiple of 4.\r\n   *\r\n   * In this case, the last group will have fewer than 4 characters, and\r\n   * padding will be inferred.  If the group has one or two characters, it decodes\r\n   * to one byte.  If the group has three characters, it decodes to two bytes.\r\n   *\r\n   * @param input Input to decode.\r\n   * @param webSafe True if we should use the web-safe alphabet.\r\n   * @return bytes representing the decoded value.\r\n   */\n  decodeStringToByteArray(input, webSafe) {\n    this.init_();\n    const charToByteMap = webSafe ? this.charToByteMapWebSafe_ : this.charToByteMap_;\n    const output = [];\n    for (let i = 0; i < input.length;) {\n      const byte1 = charToByteMap[input.charAt(i++)];\n      const haveByte2 = i < input.length;\n      const byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;\n      ++i;\n      const haveByte3 = i < input.length;\n      const byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;\n      ++i;\n      const haveByte4 = i < input.length;\n      const byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;\n      ++i;\n      if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {\n        throw new DecodeBase64StringError();\n      }\n      const outByte1 = byte1 << 2 | byte2 >> 4;\n      output.push(outByte1);\n      if (byte3 !== 64) {\n        const outByte2 = byte2 << 4 & 0xf0 | byte3 >> 2;\n        output.push(outByte2);\n        if (byte4 !== 64) {\n          const outByte3 = byte3 << 6 & 0xc0 | byte4;\n          output.push(outByte3);\n        }\n      }\n    }\n    return output;\n  },\n  /**\r\n   * Lazy static initialization function. Called before\r\n   * accessing any of the static map variables.\r\n   * @private\r\n   */\n  init_() {\n    if (!this.byteToCharMap_) {\n      this.byteToCharMap_ = {};\n      this.charToByteMap_ = {};\n      this.byteToCharMapWebSafe_ = {};\n      this.charToByteMapWebSafe_ = {};\n      // We want quick mappings back and forth, so we precompute two maps.\n      for (let i = 0; i < this.ENCODED_VALS.length; i++) {\n        this.byteToCharMap_[i] = this.ENCODED_VALS.charAt(i);\n        this.charToByteMap_[this.byteToCharMap_[i]] = i;\n        this.byteToCharMapWebSafe_[i] = this.ENCODED_VALS_WEBSAFE.charAt(i);\n        this.charToByteMapWebSafe_[this.byteToCharMapWebSafe_[i]] = i;\n        // Be forgiving when decoding and correctly decode both encodings.\n        if (i >= this.ENCODED_VALS_BASE.length) {\n          this.charToByteMap_[this.ENCODED_VALS_WEBSAFE.charAt(i)] = i;\n          this.charToByteMapWebSafe_[this.ENCODED_VALS.charAt(i)] = i;\n        }\n      }\n    }\n  }\n};\n/**\r\n * An error encountered while decoding base64 string.\r\n */\nclass DecodeBase64StringError extends Error {\n  constructor() {\n    super(...arguments);\n    this.name = 'DecodeBase64StringError';\n  }\n}\n/**\r\n * URL-safe base64 encoding\r\n */\nconst base64Encode = function (str) {\n  const utf8Bytes = stringToByteArray$1(str);\n  return base64.encodeByteArray(utf8Bytes, true);\n};\n/**\r\n * URL-safe base64 encoding (without \".\" padding in the end).\r\n * e.g. Used in JSON Web Token (JWT) parts.\r\n */\nconst base64urlEncodeWithoutPadding = function (str) {\n  // Use base64url encoding and remove padding in the end (dot characters).\n  return base64Encode(str).replace(/\\./g, '');\n};\n/**\r\n * URL-safe base64 decoding\r\n *\r\n * NOTE: DO NOT use the global atob() function - it does NOT support the\r\n * base64Url variant encoding.\r\n *\r\n * @param str To be decoded\r\n * @return Decoded result, if possible\r\n */\nconst base64Decode = function (str) {\n  try {\n    return base64.decodeString(str, true);\n  } catch (e) {\n    console.error('base64Decode failed: ', e);\n  }\n  return null;\n};\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Do a deep-copy of basic JavaScript Objects or Arrays.\r\n */\nfunction deepCopy(value) {\n  return deepExtend(undefined, value);\n}\n/**\r\n * Copy properties from source to target (recursively allows extension\r\n * of Objects and Arrays).  Scalar values in the target are over-written.\r\n * If target is undefined, an object of the appropriate type will be created\r\n * (and returned).\r\n *\r\n * We recursively copy all child properties of plain Objects in the source- so\r\n * that namespace- like dictionaries are merged.\r\n *\r\n * Note that the target can be a function, in which case the properties in\r\n * the source Object are copied onto it as static properties of the Function.\r\n *\r\n * Note: we don't merge __proto__ to prevent prototype pollution\r\n */\nfunction deepExtend(target, source) {\n  if (!(source instanceof Object)) {\n    return source;\n  }\n  switch (source.constructor) {\n    case Date:\n      // Treat Dates like scalars; if the target date object had any child\n      // properties - they will be lost!\n      const dateValue = source;\n      return new Date(dateValue.getTime());\n    case Object:\n      if (target === undefined) {\n        target = {};\n      }\n      break;\n    case Array:\n      // Always copy the array source and overwrite the target.\n      target = [];\n      break;\n    default:\n      // Not a plain Object - treat it as a scalar.\n      return source;\n  }\n  for (const prop in source) {\n    // use isValidKey to guard against prototype pollution. See https://snyk.io/vuln/SNYK-JS-LODASH-450202\n    if (!source.hasOwnProperty(prop) || !isValidKey(prop)) {\n      continue;\n    }\n    target[prop] = deepExtend(target[prop], source[prop]);\n  }\n  return target;\n}\nfunction isValidKey(key) {\n  return key !== '__proto__';\n}\n\n/**\r\n * @license\r\n * Copyright 2022 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Polyfill for `globalThis` object.\r\n * @returns the `globalThis` object for the given environment.\r\n * @public\r\n */\nfunction getGlobal() {\n  if (typeof self !== 'undefined') {\n    return self;\n  }\n  if (typeof window !== 'undefined') {\n    return window;\n  }\n  if (typeof global !== 'undefined') {\n    return global;\n  }\n  throw new Error('Unable to locate global object.');\n}\n\n/**\r\n * @license\r\n * Copyright 2022 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nconst getDefaultsFromGlobal = () => getGlobal().__FIREBASE_DEFAULTS__;\n/**\r\n * Attempt to read defaults from a JSON string provided to\r\n * process(.)env(.)__FIREBASE_DEFAULTS__ or a JSON file whose path is in\r\n * process(.)env(.)__FIREBASE_DEFAULTS_PATH__\r\n * The dots are in parens because certain compilers (Vite?) cannot\r\n * handle seeing that variable in comments.\r\n * See https://github.com/firebase/firebase-js-sdk/issues/6838\r\n */\nconst getDefaultsFromEnvVariable = () => {\n  if (typeof process === 'undefined' || typeof process.env === 'undefined') {\n    return;\n  }\n  const defaultsJsonString = process.env.__FIREBASE_DEFAULTS__;\n  if (defaultsJsonString) {\n    return JSON.parse(defaultsJsonString);\n  }\n};\nconst getDefaultsFromCookie = () => {\n  if (typeof document === 'undefined') {\n    return;\n  }\n  let match;\n  try {\n    match = document.cookie.match(/__FIREBASE_DEFAULTS__=([^;]+)/);\n  } catch (e) {\n    // Some environments such as Angular Universal SSR have a\n    // `document` object but error on accessing `document.cookie`.\n    return;\n  }\n  const decoded = match && base64Decode(match[1]);\n  return decoded && JSON.parse(decoded);\n};\n/**\r\n * Get the __FIREBASE_DEFAULTS__ object. It checks in order:\r\n * (1) if such an object exists as a property of `globalThis`\r\n * (2) if such an object was provided on a shell environment variable\r\n * (3) if such an object exists in a cookie\r\n * @public\r\n */\nconst getDefaults = () => {\n  try {\n    return getDefaultsFromGlobal() || getDefaultsFromEnvVariable() || getDefaultsFromCookie();\n  } catch (e) {\n    /**\r\n     * Catch-all for being unable to get __FIREBASE_DEFAULTS__ due\r\n     * to any environment case we have not accounted for. Log to\r\n     * info instead of swallowing so we can find these unknown cases\r\n     * and add paths for them if needed.\r\n     */\n    console.info(`Unable to get __FIREBASE_DEFAULTS__ due to: ${e}`);\n    return;\n  }\n};\n/**\r\n * Returns emulator host stored in the __FIREBASE_DEFAULTS__ object\r\n * for the given product.\r\n * @returns a URL host formatted like `127.0.0.1:9999` or `[::1]:4000` if available\r\n * @public\r\n */\nconst getDefaultEmulatorHost = productName => {\n  var _a, _b;\n  return (_b = (_a = getDefaults()) === null || _a === void 0 ? void 0 : _a.emulatorHosts) === null || _b === void 0 ? void 0 : _b[productName];\n};\n/**\r\n * Returns emulator hostname and port stored in the __FIREBASE_DEFAULTS__ object\r\n * for the given product.\r\n * @returns a pair of hostname and port like `[\"::1\", 4000]` if available\r\n * @public\r\n */\nconst getDefaultEmulatorHostnameAndPort = productName => {\n  const host = getDefaultEmulatorHost(productName);\n  if (!host) {\n    return undefined;\n  }\n  const separatorIndex = host.lastIndexOf(':'); // Finding the last since IPv6 addr also has colons.\n  if (separatorIndex <= 0 || separatorIndex + 1 === host.length) {\n    throw new Error(`Invalid host ${host} with no separate hostname and port!`);\n  }\n  // eslint-disable-next-line no-restricted-globals\n  const port = parseInt(host.substring(separatorIndex + 1), 10);\n  if (host[0] === '[') {\n    // Bracket-quoted `[ipv6addr]:port` => return \"ipv6addr\" (without brackets).\n    return [host.substring(1, separatorIndex - 1), port];\n  } else {\n    return [host.substring(0, separatorIndex), port];\n  }\n};\n/**\r\n * Returns Firebase app config stored in the __FIREBASE_DEFAULTS__ object.\r\n * @public\r\n */\nconst getDefaultAppConfig = () => {\n  var _a;\n  return (_a = getDefaults()) === null || _a === void 0 ? void 0 : _a.config;\n};\n/**\r\n * Returns an experimental setting on the __FIREBASE_DEFAULTS__ object (properties\r\n * prefixed by \"_\")\r\n * @public\r\n */\nconst getExperimentalSetting = name => {\n  var _a;\n  return (_a = getDefaults()) === null || _a === void 0 ? void 0 : _a[`_${name}`];\n};\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nclass Deferred {\n  constructor() {\n    this.reject = () => {};\n    this.resolve = () => {};\n    this.promise = new Promise((resolve, reject) => {\n      this.resolve = resolve;\n      this.reject = reject;\n    });\n  }\n  /**\r\n   * Our API internals are not promiseified and cannot because our callback APIs have subtle expectations around\r\n   * invoking promises inline, which Promises are forbidden to do. This method accepts an optional node-style callback\r\n   * and returns a node-style callback which will resolve or reject the Deferred's promise.\r\n   */\n  wrapCallback(callback) {\n    return (error, value) => {\n      if (error) {\n        this.reject(error);\n      } else {\n        this.resolve(value);\n      }\n      if (typeof callback === 'function') {\n        // Attaching noop handler just in case developer wasn't expecting\n        // promises\n        this.promise.catch(() => {});\n        // Some of our callbacks don't expect a value and our own tests\n        // assert that the parameter length is 1\n        if (callback.length === 1) {\n          callback(error);\n        } else {\n          callback(error, value);\n        }\n      }\n    };\n  }\n}\n\n/**\r\n * @license\r\n * Copyright 2021 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nfunction createMockUserToken(token, projectId) {\n  if (token.uid) {\n    throw new Error('The \"uid\" field is no longer supported by mockUserToken. Please use \"sub\" instead for Firebase Auth User ID.');\n  }\n  // Unsecured JWTs use \"none\" as the algorithm.\n  const header = {\n    alg: 'none',\n    type: 'JWT'\n  };\n  const project = projectId || 'demo-project';\n  const iat = token.iat || 0;\n  const sub = token.sub || token.user_id;\n  if (!sub) {\n    throw new Error(\"mockUserToken must contain 'sub' or 'user_id' field!\");\n  }\n  const payload = Object.assign({\n    // Set all required fields to decent defaults\n    iss: `https://securetoken.google.com/${project}`,\n    aud: project,\n    iat,\n    exp: iat + 3600,\n    auth_time: iat,\n    sub,\n    user_id: sub,\n    firebase: {\n      sign_in_provider: 'custom',\n      identities: {}\n    }\n  }, token);\n  // Unsecured JWTs use the empty string as a signature.\n  const signature = '';\n  return [base64urlEncodeWithoutPadding(JSON.stringify(header)), base64urlEncodeWithoutPadding(JSON.stringify(payload)), signature].join('.');\n}\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Returns navigator.userAgent string or '' if it's not defined.\r\n * @return user agent string\r\n */\nfunction getUA() {\n  if (typeof navigator !== 'undefined' && typeof navigator['userAgent'] === 'string') {\n    return navigator['userAgent'];\n  } else {\n    return '';\n  }\n}\n/**\r\n * Detect Cordova / PhoneGap / Ionic frameworks on a mobile device.\r\n *\r\n * Deliberately does not rely on checking `file://` URLs (as this fails PhoneGap\r\n * in the Ripple emulator) nor Cordova `onDeviceReady`, which would normally\r\n * wait for a callback.\r\n */\nfunction isMobileCordova() {\n  return typeof window !== 'undefined' &&\n  // @ts-ignore Setting up an broadly applicable index signature for Window\n  // just to deal with this case would probably be a bad idea.\n  !!(window['cordova'] || window['phonegap'] || window['PhoneGap']) && /ios|iphone|ipod|ipad|android|blackberry|iemobile/i.test(getUA());\n}\n/**\r\n * Detect Node.js.\r\n *\r\n * @return true if Node.js environment is detected or specified.\r\n */\n// Node detection logic from: https://github.com/iliakan/detect-node/\nfunction isNode() {\n  var _a;\n  const forceEnvironment = (_a = getDefaults()) === null || _a === void 0 ? void 0 : _a.forceEnvironment;\n  if (forceEnvironment === 'node') {\n    return true;\n  } else if (forceEnvironment === 'browser') {\n    return false;\n  }\n  try {\n    return Object.prototype.toString.call(global.process) === '[object process]';\n  } catch (e) {\n    return false;\n  }\n}\n/**\r\n * Detect Browser Environment\r\n */\nfunction isBrowser() {\n  return typeof self === 'object' && self.self === self;\n}\nfunction isBrowserExtension() {\n  const runtime = typeof chrome === 'object' ? chrome.runtime : typeof browser === 'object' ? browser.runtime : undefined;\n  return typeof runtime === 'object' && runtime.id !== undefined;\n}\n/**\r\n * Detect React Native.\r\n *\r\n * @return true if ReactNative environment is detected.\r\n */\nfunction isReactNative() {\n  return typeof navigator === 'object' && navigator['product'] === 'ReactNative';\n}\n/** Detects Electron apps. */\nfunction isElectron() {\n  return getUA().indexOf('Electron/') >= 0;\n}\n/** Detects Internet Explorer. */\nfunction isIE() {\n  const ua = getUA();\n  return ua.indexOf('MSIE ') >= 0 || ua.indexOf('Trident/') >= 0;\n}\n/** Detects Universal Windows Platform apps. */\nfunction isUWP() {\n  return getUA().indexOf('MSAppHost/') >= 0;\n}\n/**\r\n * Detect whether the current SDK build is the Node version.\r\n *\r\n * @return true if it's the Node SDK build.\r\n */\nfunction isNodeSdk() {\n  return CONSTANTS.NODE_CLIENT === true || CONSTANTS.NODE_ADMIN === true;\n}\n/** Returns true if we are running in Safari. */\nfunction isSafari() {\n  return !isNode() && navigator.userAgent.includes('Safari') && !navigator.userAgent.includes('Chrome');\n}\n/**\r\n * This method checks if indexedDB is supported by current browser/service worker context\r\n * @return true if indexedDB is supported by current browser/service worker context\r\n */\nfunction isIndexedDBAvailable() {\n  try {\n    return typeof indexedDB === 'object';\n  } catch (e) {\n    return false;\n  }\n}\n/**\r\n * This method validates browser/sw context for indexedDB by opening a dummy indexedDB database and reject\r\n * if errors occur during the database open operation.\r\n *\r\n * @throws exception if current browser/sw context can't run idb.open (ex: Safari iframe, Firefox\r\n * private browsing)\r\n */\nfunction validateIndexedDBOpenable() {\n  return new Promise((resolve, reject) => {\n    try {\n      let preExist = true;\n      const DB_CHECK_NAME = 'validate-browser-context-for-indexeddb-analytics-module';\n      const request = self.indexedDB.open(DB_CHECK_NAME);\n      request.onsuccess = () => {\n        request.result.close();\n        // delete database only when it doesn't pre-exist\n        if (!preExist) {\n          self.indexedDB.deleteDatabase(DB_CHECK_NAME);\n        }\n        resolve(true);\n      };\n      request.onupgradeneeded = () => {\n        preExist = false;\n      };\n      request.onerror = () => {\n        var _a;\n        reject(((_a = request.error) === null || _a === void 0 ? void 0 : _a.message) || '');\n      };\n    } catch (error) {\n      reject(error);\n    }\n  });\n}\n/**\r\n *\r\n * This method checks whether cookie is enabled within current browser\r\n * @return true if cookie is enabled within current browser\r\n */\nfunction areCookiesEnabled() {\n  if (typeof navigator === 'undefined' || !navigator.cookieEnabled) {\n    return false;\n  }\n  return true;\n}\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * @fileoverview Standardized Firebase Error.\r\n *\r\n * Usage:\r\n *\r\n *   // Typescript string literals for type-safe codes\r\n *   type Err =\r\n *     'unknown' |\r\n *     'object-not-found'\r\n *     ;\r\n *\r\n *   // Closure enum for type-safe error codes\r\n *   // at-enum {string}\r\n *   var Err = {\r\n *     UNKNOWN: 'unknown',\r\n *     OBJECT_NOT_FOUND: 'object-not-found',\r\n *   }\r\n *\r\n *   let errors: Map<Err, string> = {\r\n *     'generic-error': \"Unknown error\",\r\n *     'file-not-found': \"Could not find file: {$file}\",\r\n *   };\r\n *\r\n *   // Type-safe function - must pass a valid error code as param.\r\n *   let error = new ErrorFactory<Err>('service', 'Service', errors);\r\n *\r\n *   ...\r\n *   throw error.create(Err.GENERIC);\r\n *   ...\r\n *   throw error.create(Err.FILE_NOT_FOUND, {'file': fileName});\r\n *   ...\r\n *   // Service: Could not file file: foo.txt (service/file-not-found).\r\n *\r\n *   catch (e) {\r\n *     assert(e.message === \"Could not find file: foo.txt.\");\r\n *     if ((e as FirebaseError)?.code === 'service/file-not-found') {\r\n *       console.log(\"Could not read file: \" + e['file']);\r\n *     }\r\n *   }\r\n */\nconst ERROR_NAME = 'FirebaseError';\n// Based on code from:\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Custom_Error_Types\nclass FirebaseError extends Error {\n  constructor( /** The error code for this error. */\n  code, message, /** Custom data for this error. */\n  customData) {\n    super(message);\n    this.code = code;\n    this.customData = customData;\n    /** The custom name for all FirebaseErrors. */\n    this.name = ERROR_NAME;\n    // Fix For ES5\n    // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\n    Object.setPrototypeOf(this, FirebaseError.prototype);\n    // Maintains proper stack trace for where our error was thrown.\n    // Only available on V8.\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, ErrorFactory.prototype.create);\n    }\n  }\n}\nclass ErrorFactory {\n  constructor(service, serviceName, errors) {\n    this.service = service;\n    this.serviceName = serviceName;\n    this.errors = errors;\n  }\n  create(code, ...data) {\n    const customData = data[0] || {};\n    const fullCode = `${this.service}/${code}`;\n    const template = this.errors[code];\n    const message = template ? replaceTemplate(template, customData) : 'Error';\n    // Service Name: Error message (service/code).\n    const fullMessage = `${this.serviceName}: ${message} (${fullCode}).`;\n    const error = new FirebaseError(fullCode, fullMessage, customData);\n    return error;\n  }\n}\nfunction replaceTemplate(template, data) {\n  return template.replace(PATTERN, (_, key) => {\n    const value = data[key];\n    return value != null ? String(value) : `<${key}?>`;\n  });\n}\nconst PATTERN = /\\{\\$([^}]+)}/g;\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Evaluates a JSON string into a javascript object.\r\n *\r\n * @param {string} str A string containing JSON.\r\n * @return {*} The javascript object representing the specified JSON.\r\n */\nfunction jsonEval(str) {\n  return JSON.parse(str);\n}\n/**\r\n * Returns JSON representing a javascript object.\r\n * @param {*} data Javascript object to be stringified.\r\n * @return {string} The JSON contents of the object.\r\n */\nfunction stringify(data) {\n  return JSON.stringify(data);\n}\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Decodes a Firebase auth. token into constituent parts.\r\n *\r\n * Notes:\r\n * - May return with invalid / incomplete claims if there's no native base64 decoding support.\r\n * - Doesn't check if the token is actually valid.\r\n */\nconst decode = function (token) {\n  let header = {},\n    claims = {},\n    data = {},\n    signature = '';\n  try {\n    const parts = token.split('.');\n    header = jsonEval(base64Decode(parts[0]) || '');\n    claims = jsonEval(base64Decode(parts[1]) || '');\n    signature = parts[2];\n    data = claims['d'] || {};\n    delete claims['d'];\n  } catch (e) {}\n  return {\n    header,\n    claims,\n    data,\n    signature\n  };\n};\n/**\r\n * Decodes a Firebase auth. token and checks the validity of its time-based claims. Will return true if the\r\n * token is within the time window authorized by the 'nbf' (not-before) and 'iat' (issued-at) claims.\r\n *\r\n * Notes:\r\n * - May return a false negative if there's no native base64 decoding support.\r\n * - Doesn't check if the token is actually valid.\r\n */\nconst isValidTimestamp = function (token) {\n  const claims = decode(token).claims;\n  const now = Math.floor(new Date().getTime() / 1000);\n  let validSince = 0,\n    validUntil = 0;\n  if (typeof claims === 'object') {\n    if (claims.hasOwnProperty('nbf')) {\n      validSince = claims['nbf'];\n    } else if (claims.hasOwnProperty('iat')) {\n      validSince = claims['iat'];\n    }\n    if (claims.hasOwnProperty('exp')) {\n      validUntil = claims['exp'];\n    } else {\n      // token will expire after 24h by default\n      validUntil = validSince + 86400;\n    }\n  }\n  return !!now && !!validSince && !!validUntil && now >= validSince && now <= validUntil;\n};\n/**\r\n * Decodes a Firebase auth. token and returns its issued at time if valid, null otherwise.\r\n *\r\n * Notes:\r\n * - May return null if there's no native base64 decoding support.\r\n * - Doesn't check if the token is actually valid.\r\n */\nconst issuedAtTime = function (token) {\n  const claims = decode(token).claims;\n  if (typeof claims === 'object' && claims.hasOwnProperty('iat')) {\n    return claims['iat'];\n  }\n  return null;\n};\n/**\r\n * Decodes a Firebase auth. token and checks the validity of its format. Expects a valid issued-at time.\r\n *\r\n * Notes:\r\n * - May return a false negative if there's no native base64 decoding support.\r\n * - Doesn't check if the token is actually valid.\r\n */\nconst isValidFormat = function (token) {\n  const decoded = decode(token),\n    claims = decoded.claims;\n  return !!claims && typeof claims === 'object' && claims.hasOwnProperty('iat');\n};\n/**\r\n * Attempts to peer into an auth token and determine if it's an admin auth token by looking at the claims portion.\r\n *\r\n * Notes:\r\n * - May return a false negative if there's no native base64 decoding support.\r\n * - Doesn't check if the token is actually valid.\r\n */\nconst isAdmin = function (token) {\n  const claims = decode(token).claims;\n  return typeof claims === 'object' && claims['admin'] === true;\n};\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nfunction contains(obj, key) {\n  return Object.prototype.hasOwnProperty.call(obj, key);\n}\nfunction safeGet(obj, key) {\n  if (Object.prototype.hasOwnProperty.call(obj, key)) {\n    return obj[key];\n  } else {\n    return undefined;\n  }\n}\nfunction isEmpty(obj) {\n  for (const key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      return false;\n    }\n  }\n  return true;\n}\nfunction map(obj, fn, contextObj) {\n  const res = {};\n  for (const key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      res[key] = fn.call(contextObj, obj[key], key, obj);\n    }\n  }\n  return res;\n}\n/**\r\n * Deep equal two objects. Support Arrays and Objects.\r\n */\nfunction deepEqual(a, b) {\n  if (a === b) {\n    return true;\n  }\n  const aKeys = Object.keys(a);\n  const bKeys = Object.keys(b);\n  for (const k of aKeys) {\n    if (!bKeys.includes(k)) {\n      return false;\n    }\n    const aProp = a[k];\n    const bProp = b[k];\n    if (isObject(aProp) && isObject(bProp)) {\n      if (!deepEqual(aProp, bProp)) {\n        return false;\n      }\n    } else if (aProp !== bProp) {\n      return false;\n    }\n  }\n  for (const k of bKeys) {\n    if (!aKeys.includes(k)) {\n      return false;\n    }\n  }\n  return true;\n}\nfunction isObject(thing) {\n  return thing !== null && typeof thing === 'object';\n}\n\n/**\r\n * @license\r\n * Copyright 2022 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Rejects if the given promise doesn't resolve in timeInMS milliseconds.\r\n * @internal\r\n */\nfunction promiseWithTimeout(promise, timeInMS = 2000) {\n  const deferredPromise = new Deferred();\n  setTimeout(() => deferredPromise.reject('timeout!'), timeInMS);\n  promise.then(deferredPromise.resolve, deferredPromise.reject);\n  return deferredPromise.promise;\n}\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Returns a querystring-formatted string (e.g. &arg=val&arg2=val2) from a\r\n * params object (e.g. {arg: 'val', arg2: 'val2'})\r\n * Note: You must prepend it with ? when adding it to a URL.\r\n */\nfunction querystring(querystringParams) {\n  const params = [];\n  for (const [key, value] of Object.entries(querystringParams)) {\n    if (Array.isArray(value)) {\n      value.forEach(arrayVal => {\n        params.push(encodeURIComponent(key) + '=' + encodeURIComponent(arrayVal));\n      });\n    } else {\n      params.push(encodeURIComponent(key) + '=' + encodeURIComponent(value));\n    }\n  }\n  return params.length ? '&' + params.join('&') : '';\n}\n/**\r\n * Decodes a querystring (e.g. ?arg=val&arg2=val2) into a params object\r\n * (e.g. {arg: 'val', arg2: 'val2'})\r\n */\nfunction querystringDecode(querystring) {\n  const obj = {};\n  const tokens = querystring.replace(/^\\?/, '').split('&');\n  tokens.forEach(token => {\n    if (token) {\n      const [key, value] = token.split('=');\n      obj[decodeURIComponent(key)] = decodeURIComponent(value);\n    }\n  });\n  return obj;\n}\n/**\r\n * Extract the query string part of a URL, including the leading question mark (if present).\r\n */\nfunction extractQuerystring(url) {\n  const queryStart = url.indexOf('?');\n  if (!queryStart) {\n    return '';\n  }\n  const fragmentStart = url.indexOf('#', queryStart);\n  return url.substring(queryStart, fragmentStart > 0 ? fragmentStart : undefined);\n}\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * @fileoverview SHA-1 cryptographic hash.\r\n * Variable names follow the notation in FIPS PUB 180-3:\r\n * http://csrc.nist.gov/publications/fips/fips180-3/fips180-3_final.pdf.\r\n *\r\n * Usage:\r\n *   var sha1 = new sha1();\r\n *   sha1.update(bytes);\r\n *   var hash = sha1.digest();\r\n *\r\n * Performance:\r\n *   Chrome 23:   ~400 Mbit/s\r\n *   Firefox 16:  ~250 Mbit/s\r\n *\r\n */\n/**\r\n * SHA-1 cryptographic hash constructor.\r\n *\r\n * The properties declared here are discussed in the above algorithm document.\r\n * @constructor\r\n * @final\r\n * @struct\r\n */\nclass Sha1 {\n  constructor() {\n    /**\r\n     * Holds the previous values of accumulated variables a-e in the compress_\r\n     * function.\r\n     * @private\r\n     */\n    this.chain_ = [];\n    /**\r\n     * A buffer holding the partially computed hash result.\r\n     * @private\r\n     */\n    this.buf_ = [];\n    /**\r\n     * An array of 80 bytes, each a part of the message to be hashed.  Referred to\r\n     * as the message schedule in the docs.\r\n     * @private\r\n     */\n    this.W_ = [];\n    /**\r\n     * Contains data needed to pad messages less than 64 bytes.\r\n     * @private\r\n     */\n    this.pad_ = [];\n    /**\r\n     * @private {number}\r\n     */\n    this.inbuf_ = 0;\n    /**\r\n     * @private {number}\r\n     */\n    this.total_ = 0;\n    this.blockSize = 512 / 8;\n    this.pad_[0] = 128;\n    for (let i = 1; i < this.blockSize; ++i) {\n      this.pad_[i] = 0;\n    }\n    this.reset();\n  }\n  reset() {\n    this.chain_[0] = 0x67452301;\n    this.chain_[1] = 0xefcdab89;\n    this.chain_[2] = 0x98badcfe;\n    this.chain_[3] = 0x10325476;\n    this.chain_[4] = 0xc3d2e1f0;\n    this.inbuf_ = 0;\n    this.total_ = 0;\n  }\n  /**\r\n   * Internal compress helper function.\r\n   * @param buf Block to compress.\r\n   * @param offset Offset of the block in the buffer.\r\n   * @private\r\n   */\n  compress_(buf, offset) {\n    if (!offset) {\n      offset = 0;\n    }\n    const W = this.W_;\n    // get 16 big endian words\n    if (typeof buf === 'string') {\n      for (let i = 0; i < 16; i++) {\n        // TODO(user): [bug 8140122] Recent versions of Safari for Mac OS and iOS\n        // have a bug that turns the post-increment ++ operator into pre-increment\n        // during JIT compilation.  We have code that depends heavily on SHA-1 for\n        // correctness and which is affected by this bug, so I've removed all uses\n        // of post-increment ++ in which the result value is used.  We can revert\n        // this change once the Safari bug\n        // (https://bugs.webkit.org/show_bug.cgi?id=109036) has been fixed and\n        // most clients have been updated.\n        W[i] = buf.charCodeAt(offset) << 24 | buf.charCodeAt(offset + 1) << 16 | buf.charCodeAt(offset + 2) << 8 | buf.charCodeAt(offset + 3);\n        offset += 4;\n      }\n    } else {\n      for (let i = 0; i < 16; i++) {\n        W[i] = buf[offset] << 24 | buf[offset + 1] << 16 | buf[offset + 2] << 8 | buf[offset + 3];\n        offset += 4;\n      }\n    }\n    // expand to 80 words\n    for (let i = 16; i < 80; i++) {\n      const t = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];\n      W[i] = (t << 1 | t >>> 31) & 0xffffffff;\n    }\n    let a = this.chain_[0];\n    let b = this.chain_[1];\n    let c = this.chain_[2];\n    let d = this.chain_[3];\n    let e = this.chain_[4];\n    let f, k;\n    // TODO(user): Try to unroll this loop to speed up the computation.\n    for (let i = 0; i < 80; i++) {\n      if (i < 40) {\n        if (i < 20) {\n          f = d ^ b & (c ^ d);\n          k = 0x5a827999;\n        } else {\n          f = b ^ c ^ d;\n          k = 0x6ed9eba1;\n        }\n      } else {\n        if (i < 60) {\n          f = b & c | d & (b | c);\n          k = 0x8f1bbcdc;\n        } else {\n          f = b ^ c ^ d;\n          k = 0xca62c1d6;\n        }\n      }\n      const t = (a << 5 | a >>> 27) + f + e + k + W[i] & 0xffffffff;\n      e = d;\n      d = c;\n      c = (b << 30 | b >>> 2) & 0xffffffff;\n      b = a;\n      a = t;\n    }\n    this.chain_[0] = this.chain_[0] + a & 0xffffffff;\n    this.chain_[1] = this.chain_[1] + b & 0xffffffff;\n    this.chain_[2] = this.chain_[2] + c & 0xffffffff;\n    this.chain_[3] = this.chain_[3] + d & 0xffffffff;\n    this.chain_[4] = this.chain_[4] + e & 0xffffffff;\n  }\n  update(bytes, length) {\n    // TODO(johnlenz): tighten the function signature and remove this check\n    if (bytes == null) {\n      return;\n    }\n    if (length === undefined) {\n      length = bytes.length;\n    }\n    const lengthMinusBlock = length - this.blockSize;\n    let n = 0;\n    // Using local instead of member variables gives ~5% speedup on Firefox 16.\n    const buf = this.buf_;\n    let inbuf = this.inbuf_;\n    // The outer while loop should execute at most twice.\n    while (n < length) {\n      // When we have no data in the block to top up, we can directly process the\n      // input buffer (assuming it contains sufficient data). This gives ~25%\n      // speedup on Chrome 23 and ~15% speedup on Firefox 16, but requires that\n      // the data is provided in large chunks (or in multiples of 64 bytes).\n      if (inbuf === 0) {\n        while (n <= lengthMinusBlock) {\n          this.compress_(bytes, n);\n          n += this.blockSize;\n        }\n      }\n      if (typeof bytes === 'string') {\n        while (n < length) {\n          buf[inbuf] = bytes.charCodeAt(n);\n          ++inbuf;\n          ++n;\n          if (inbuf === this.blockSize) {\n            this.compress_(buf);\n            inbuf = 0;\n            // Jump to the outer loop so we use the full-block optimization.\n            break;\n          }\n        }\n      } else {\n        while (n < length) {\n          buf[inbuf] = bytes[n];\n          ++inbuf;\n          ++n;\n          if (inbuf === this.blockSize) {\n            this.compress_(buf);\n            inbuf = 0;\n            // Jump to the outer loop so we use the full-block optimization.\n            break;\n          }\n        }\n      }\n    }\n    this.inbuf_ = inbuf;\n    this.total_ += length;\n  }\n  /** @override */\n  digest() {\n    const digest = [];\n    let totalBits = this.total_ * 8;\n    // Add pad 0x80 0x00*.\n    if (this.inbuf_ < 56) {\n      this.update(this.pad_, 56 - this.inbuf_);\n    } else {\n      this.update(this.pad_, this.blockSize - (this.inbuf_ - 56));\n    }\n    // Add # bits.\n    for (let i = this.blockSize - 1; i >= 56; i--) {\n      this.buf_[i] = totalBits & 255;\n      totalBits /= 256; // Don't use bit-shifting here!\n    }\n    this.compress_(this.buf_);\n    let n = 0;\n    for (let i = 0; i < 5; i++) {\n      for (let j = 24; j >= 0; j -= 8) {\n        digest[n] = this.chain_[i] >> j & 255;\n        ++n;\n      }\n    }\n    return digest;\n  }\n}\n\n/**\r\n * Helper to make a Subscribe function (just like Promise helps make a\r\n * Thenable).\r\n *\r\n * @param executor Function which can make calls to a single Observer\r\n *     as a proxy.\r\n * @param onNoObservers Callback when count of Observers goes to zero.\r\n */\nfunction createSubscribe(executor, onNoObservers) {\n  const proxy = new ObserverProxy(executor, onNoObservers);\n  return proxy.subscribe.bind(proxy);\n}\n/**\r\n * Implement fan-out for any number of Observers attached via a subscribe\r\n * function.\r\n */\nclass ObserverProxy {\n  /**\r\n   * @param executor Function which can make calls to a single Observer\r\n   *     as a proxy.\r\n   * @param onNoObservers Callback when count of Observers goes to zero.\r\n   */\n  constructor(executor, onNoObservers) {\n    this.observers = [];\n    this.unsubscribes = [];\n    this.observerCount = 0;\n    // Micro-task scheduling by calling task.then().\n    this.task = Promise.resolve();\n    this.finalized = false;\n    this.onNoObservers = onNoObservers;\n    // Call the executor asynchronously so subscribers that are called\n    // synchronously after the creation of the subscribe function\n    // can still receive the very first value generated in the executor.\n    this.task.then(() => {\n      executor(this);\n    }).catch(e => {\n      this.error(e);\n    });\n  }\n  next(value) {\n    this.forEachObserver(observer => {\n      observer.next(value);\n    });\n  }\n  error(error) {\n    this.forEachObserver(observer => {\n      observer.error(error);\n    });\n    this.close(error);\n  }\n  complete() {\n    this.forEachObserver(observer => {\n      observer.complete();\n    });\n    this.close();\n  }\n  /**\r\n   * Subscribe function that can be used to add an Observer to the fan-out list.\r\n   *\r\n   * - We require that no event is sent to a subscriber sychronously to their\r\n   *   call to subscribe().\r\n   */\n  subscribe(nextOrObserver, error, complete) {\n    let observer;\n    if (nextOrObserver === undefined && error === undefined && complete === undefined) {\n      throw new Error('Missing Observer.');\n    }\n    // Assemble an Observer object when passed as callback functions.\n    if (implementsAnyMethods(nextOrObserver, ['next', 'error', 'complete'])) {\n      observer = nextOrObserver;\n    } else {\n      observer = {\n        next: nextOrObserver,\n        error,\n        complete\n      };\n    }\n    if (observer.next === undefined) {\n      observer.next = noop;\n    }\n    if (observer.error === undefined) {\n      observer.error = noop;\n    }\n    if (observer.complete === undefined) {\n      observer.complete = noop;\n    }\n    const unsub = this.unsubscribeOne.bind(this, this.observers.length);\n    // Attempt to subscribe to a terminated Observable - we\n    // just respond to the Observer with the final error or complete\n    // event.\n    if (this.finalized) {\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      this.task.then(() => {\n        try {\n          if (this.finalError) {\n            observer.error(this.finalError);\n          } else {\n            observer.complete();\n          }\n        } catch (e) {\n          // nothing\n        }\n        return;\n      });\n    }\n    this.observers.push(observer);\n    return unsub;\n  }\n  // Unsubscribe is synchronous - we guarantee that no events are sent to\n  // any unsubscribed Observer.\n  unsubscribeOne(i) {\n    if (this.observers === undefined || this.observers[i] === undefined) {\n      return;\n    }\n    delete this.observers[i];\n    this.observerCount -= 1;\n    if (this.observerCount === 0 && this.onNoObservers !== undefined) {\n      this.onNoObservers(this);\n    }\n  }\n  forEachObserver(fn) {\n    if (this.finalized) {\n      // Already closed by previous event....just eat the additional values.\n      return;\n    }\n    // Since sendOne calls asynchronously - there is no chance that\n    // this.observers will become undefined.\n    for (let i = 0; i < this.observers.length; i++) {\n      this.sendOne(i, fn);\n    }\n  }\n  // Call the Observer via one of it's callback function. We are careful to\n  // confirm that the observe has not been unsubscribed since this asynchronous\n  // function had been queued.\n  sendOne(i, fn) {\n    // Execute the callback asynchronously\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.task.then(() => {\n      if (this.observers !== undefined && this.observers[i] !== undefined) {\n        try {\n          fn(this.observers[i]);\n        } catch (e) {\n          // Ignore exceptions raised in Observers or missing methods of an\n          // Observer.\n          // Log error to console. b/31404806\n          if (typeof console !== 'undefined' && console.error) {\n            console.error(e);\n          }\n        }\n      }\n    });\n  }\n  close(err) {\n    if (this.finalized) {\n      return;\n    }\n    this.finalized = true;\n    if (err !== undefined) {\n      this.finalError = err;\n    }\n    // Proxy is no longer needed - garbage collect references\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.task.then(() => {\n      this.observers = undefined;\n      this.onNoObservers = undefined;\n    });\n  }\n}\n/** Turn synchronous function into one called asynchronously. */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction async(fn, onError) {\n  return (...args) => {\n    Promise.resolve(true).then(() => {\n      fn(...args);\n    }).catch(error => {\n      if (onError) {\n        onError(error);\n      }\n    });\n  };\n}\n/**\r\n * Return true if the object passed in implements any of the named methods.\r\n */\nfunction implementsAnyMethods(obj, methods) {\n  if (typeof obj !== 'object' || obj === null) {\n    return false;\n  }\n  for (const method of methods) {\n    if (method in obj && typeof obj[method] === 'function') {\n      return true;\n    }\n  }\n  return false;\n}\nfunction noop() {\n  // do nothing\n}\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Check to make sure the appropriate number of arguments are provided for a public function.\r\n * Throws an error if it fails.\r\n *\r\n * @param fnName The function name\r\n * @param minCount The minimum number of arguments to allow for the function call\r\n * @param maxCount The maximum number of argument to allow for the function call\r\n * @param argCount The actual number of arguments provided.\r\n */\nconst validateArgCount = function (fnName, minCount, maxCount, argCount) {\n  let argError;\n  if (argCount < minCount) {\n    argError = 'at least ' + minCount;\n  } else if (argCount > maxCount) {\n    argError = maxCount === 0 ? 'none' : 'no more than ' + maxCount;\n  }\n  if (argError) {\n    const error = fnName + ' failed: Was called with ' + argCount + (argCount === 1 ? ' argument.' : ' arguments.') + ' Expects ' + argError + '.';\n    throw new Error(error);\n  }\n};\n/**\r\n * Generates a string to prefix an error message about failed argument validation\r\n *\r\n * @param fnName The function name\r\n * @param argName The name of the argument\r\n * @return The prefix to add to the error thrown for validation.\r\n */\nfunction errorPrefix(fnName, argName) {\n  return `${fnName} failed: ${argName} argument `;\n}\n/**\r\n * @param fnName\r\n * @param argumentNumber\r\n * @param namespace\r\n * @param optional\r\n */\nfunction validateNamespace(fnName, namespace, optional) {\n  if (optional && !namespace) {\n    return;\n  }\n  if (typeof namespace !== 'string') {\n    //TODO: I should do more validation here. We only allow certain chars in namespaces.\n    throw new Error(errorPrefix(fnName, 'namespace') + 'must be a valid firebase namespace.');\n  }\n}\nfunction validateCallback(fnName, argumentName,\n// eslint-disable-next-line @typescript-eslint/ban-types\ncallback, optional) {\n  if (optional && !callback) {\n    return;\n  }\n  if (typeof callback !== 'function') {\n    throw new Error(errorPrefix(fnName, argumentName) + 'must be a valid function.');\n  }\n}\nfunction validateContextObject(fnName, argumentName, context, optional) {\n  if (optional && !context) {\n    return;\n  }\n  if (typeof context !== 'object' || context === null) {\n    throw new Error(errorPrefix(fnName, argumentName) + 'must be a valid context object.');\n  }\n}\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n// Code originally came from goog.crypt.stringToUtf8ByteArray, but for some reason they\n// automatically replaced '\\r\\n' with '\\n', and they didn't handle surrogate pairs,\n// so it's been modified.\n// Note that not all Unicode characters appear as single characters in JavaScript strings.\n// fromCharCode returns the UTF-16 encoding of a character - so some Unicode characters\n// use 2 characters in Javascript.  All 4-byte UTF-8 characters begin with a first\n// character in the range 0xD800 - 0xDBFF (the first character of a so-called surrogate\n// pair).\n// See http://www.ecma-international.org/ecma-262/5.1/#sec-15.1.3\n/**\r\n * @param {string} str\r\n * @return {Array}\r\n */\nconst stringToByteArray = function (str) {\n  const out = [];\n  let p = 0;\n  for (let i = 0; i < str.length; i++) {\n    let c = str.charCodeAt(i);\n    // Is this the lead surrogate in a surrogate pair?\n    if (c >= 0xd800 && c <= 0xdbff) {\n      const high = c - 0xd800; // the high 10 bits.\n      i++;\n      assert(i < str.length, 'Surrogate pair missing trail surrogate.');\n      const low = str.charCodeAt(i) - 0xdc00; // the low 10 bits.\n      c = 0x10000 + (high << 10) + low;\n    }\n    if (c < 128) {\n      out[p++] = c;\n    } else if (c < 2048) {\n      out[p++] = c >> 6 | 192;\n      out[p++] = c & 63 | 128;\n    } else if (c < 65536) {\n      out[p++] = c >> 12 | 224;\n      out[p++] = c >> 6 & 63 | 128;\n      out[p++] = c & 63 | 128;\n    } else {\n      out[p++] = c >> 18 | 240;\n      out[p++] = c >> 12 & 63 | 128;\n      out[p++] = c >> 6 & 63 | 128;\n      out[p++] = c & 63 | 128;\n    }\n  }\n  return out;\n};\n/**\r\n * Calculate length without actually converting; useful for doing cheaper validation.\r\n * @param {string} str\r\n * @return {number}\r\n */\nconst stringLength = function (str) {\n  let p = 0;\n  for (let i = 0; i < str.length; i++) {\n    const c = str.charCodeAt(i);\n    if (c < 128) {\n      p++;\n    } else if (c < 2048) {\n      p += 2;\n    } else if (c >= 0xd800 && c <= 0xdbff) {\n      // Lead surrogate of a surrogate pair.  The pair together will take 4 bytes to represent.\n      p += 4;\n      i++; // skip trail surrogate.\n    } else {\n      p += 3;\n    }\n  }\n  return p;\n};\n\n/**\r\n * @license\r\n * Copyright 2022 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Copied from https://stackoverflow.com/a/2117523\r\n * Generates a new uuid.\r\n * @public\r\n */\nconst uuidv4 = function () {\n  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {\n    const r = Math.random() * 16 | 0,\n      v = c === 'x' ? r : r & 0x3 | 0x8;\n    return v.toString(16);\n  });\n};\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * The amount of milliseconds to exponentially increase.\r\n */\nconst DEFAULT_INTERVAL_MILLIS = 1000;\n/**\r\n * The factor to backoff by.\r\n * Should be a number greater than 1.\r\n */\nconst DEFAULT_BACKOFF_FACTOR = 2;\n/**\r\n * The maximum milliseconds to increase to.\r\n *\r\n * <p>Visible for testing\r\n */\nconst MAX_VALUE_MILLIS = 4 * 60 * 60 * 1000; // Four hours, like iOS and Android.\n/**\r\n * The percentage of backoff time to randomize by.\r\n * See\r\n * http://go/safe-client-behavior#step-1-determine-the-appropriate-retry-interval-to-handle-spike-traffic\r\n * for context.\r\n *\r\n * <p>Visible for testing\r\n */\nconst RANDOM_FACTOR = 0.5;\n/**\r\n * Based on the backoff method from\r\n * https://github.com/google/closure-library/blob/master/closure/goog/math/exponentialbackoff.js.\r\n * Extracted here so we don't need to pass metadata and a stateful ExponentialBackoff object around.\r\n */\nfunction calculateBackoffMillis(backoffCount, intervalMillis = DEFAULT_INTERVAL_MILLIS, backoffFactor = DEFAULT_BACKOFF_FACTOR) {\n  // Calculates an exponentially increasing value.\n  // Deviation: calculates value from count and a constant interval, so we only need to save value\n  // and count to restore state.\n  const currBaseValue = intervalMillis * Math.pow(backoffFactor, backoffCount);\n  // A random \"fuzz\" to avoid waves of retries.\n  // Deviation: randomFactor is required.\n  const randomWait = Math.round(\n  // A fraction of the backoff value to add/subtract.\n  // Deviation: changes multiplication order to improve readability.\n  RANDOM_FACTOR * currBaseValue * (\n  // A random float (rounded to int by Math.round above) in the range [-1, 1]. Determines\n  // if we add or subtract.\n  Math.random() - 0.5) * 2);\n  // Limits backoff to max to avoid effectively permanent backoff.\n  return Math.min(MAX_VALUE_MILLIS, currBaseValue + randomWait);\n}\n\n/**\r\n * @license\r\n * Copyright 2020 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Provide English ordinal letters after a number\r\n */\nfunction ordinal(i) {\n  if (!Number.isFinite(i)) {\n    return `${i}`;\n  }\n  return i + indicator(i);\n}\nfunction indicator(i) {\n  i = Math.abs(i);\n  const cent = i % 100;\n  if (cent >= 10 && cent <= 20) {\n    return 'th';\n  }\n  const dec = i % 10;\n  if (dec === 1) {\n    return 'st';\n  }\n  if (dec === 2) {\n    return 'nd';\n  }\n  if (dec === 3) {\n    return 'rd';\n  }\n  return 'th';\n}\n\n/**\r\n * @license\r\n * Copyright 2021 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nfunction getModularInstance(service) {\n  if (service && service._delegate) {\n    return service._delegate;\n  } else {\n    return service;\n  }\n}\nexport { CONSTANTS, DecodeBase64StringError, Deferred, ErrorFactory, FirebaseError, MAX_VALUE_MILLIS, RANDOM_FACTOR, Sha1, areCookiesEnabled, assert, assertionError, async, base64, base64Decode, base64Encode, base64urlEncodeWithoutPadding, calculateBackoffMillis, contains, createMockUserToken, createSubscribe, decode, deepCopy, deepEqual, deepExtend, errorPrefix, extractQuerystring, getDefaultAppConfig, getDefaultEmulatorHost, getDefaultEmulatorHostnameAndPort, getDefaults, getExperimentalSetting, getGlobal, getModularInstance, getUA, isAdmin, isBrowser, isBrowserExtension, isElectron, isEmpty, isIE, isIndexedDBAvailable, isMobileCordova, isNode, isNodeSdk, isReactNative, isSafari, isUWP, isValidFormat, isValidTimestamp, issuedAtTime, jsonEval, map, ordinal, promiseWithTimeout, querystring, querystringDecode, safeGet, stringLength, stringToByteArray, stringify, uuidv4, validateArgCount, validateCallback, validateContextObject, validateIndexedDBOpenable, validateNamespace };\n","import { Deferred } from '@firebase/util';\n\n/**\r\n * Component for service name T, e.g. `auth`, `auth-internal`\r\n */\nclass Component {\n  /**\r\n   *\r\n   * @param name The public service name, e.g. app, auth, firestore, database\r\n   * @param instanceFactory Service factory responsible for creating the public interface\r\n   * @param type whether the service provided by the component is public or private\r\n   */\n  constructor(name, instanceFactory, type) {\n    this.name = name;\n    this.instanceFactory = instanceFactory;\n    this.type = type;\n    this.multipleInstances = false;\n    /**\r\n     * Properties to be added to the service namespace\r\n     */\n    this.serviceProps = {};\n    this.instantiationMode = \"LAZY\" /* InstantiationMode.LAZY */;\n    this.onInstanceCreated = null;\n  }\n  setInstantiationMode(mode) {\n    this.instantiationMode = mode;\n    return this;\n  }\n  setMultipleInstances(multipleInstances) {\n    this.multipleInstances = multipleInstances;\n    return this;\n  }\n  setServiceProps(props) {\n    this.serviceProps = props;\n    return this;\n  }\n  setInstanceCreatedCallback(callback) {\n    this.onInstanceCreated = callback;\n    return this;\n  }\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nconst DEFAULT_ENTRY_NAME = '[DEFAULT]';\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * Provider for instance for service name T, e.g. 'auth', 'auth-internal'\r\n * NameServiceMapping[T] is an alias for the type of the instance\r\n */\nclass Provider {\n  constructor(name, container) {\n    this.name = name;\n    this.container = container;\n    this.component = null;\n    this.instances = new Map();\n    this.instancesDeferred = new Map();\n    this.instancesOptions = new Map();\n    this.onInitCallbacks = new Map();\n  }\n  /**\r\n   * @param identifier A provider can provide mulitple instances of a service\r\n   * if this.component.multipleInstances is true.\r\n   */\n  get(identifier) {\n    // if multipleInstances is not supported, use the default name\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);\n    if (!this.instancesDeferred.has(normalizedIdentifier)) {\n      const deferred = new Deferred();\n      this.instancesDeferred.set(normalizedIdentifier, deferred);\n      if (this.isInitialized(normalizedIdentifier) || this.shouldAutoInitialize()) {\n        // initialize the service if it can be auto-initialized\n        try {\n          const instance = this.getOrInitializeService({\n            instanceIdentifier: normalizedIdentifier\n          });\n          if (instance) {\n            deferred.resolve(instance);\n          }\n        } catch (e) {\n          // when the instance factory throws an exception during get(), it should not cause\n          // a fatal error. We just return the unresolved promise in this case.\n        }\n      }\n    }\n    return this.instancesDeferred.get(normalizedIdentifier).promise;\n  }\n  getImmediate(options) {\n    var _a;\n    // if multipleInstances is not supported, use the default name\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(options === null || options === void 0 ? void 0 : options.identifier);\n    const optional = (_a = options === null || options === void 0 ? void 0 : options.optional) !== null && _a !== void 0 ? _a : false;\n    if (this.isInitialized(normalizedIdentifier) || this.shouldAutoInitialize()) {\n      try {\n        return this.getOrInitializeService({\n          instanceIdentifier: normalizedIdentifier\n        });\n      } catch (e) {\n        if (optional) {\n          return null;\n        } else {\n          throw e;\n        }\n      }\n    } else {\n      // In case a component is not initialized and should/can not be auto-initialized at the moment, return null if the optional flag is set, or throw\n      if (optional) {\n        return null;\n      } else {\n        throw Error(`Service ${this.name} is not available`);\n      }\n    }\n  }\n  getComponent() {\n    return this.component;\n  }\n  setComponent(component) {\n    if (component.name !== this.name) {\n      throw Error(`Mismatching Component ${component.name} for Provider ${this.name}.`);\n    }\n    if (this.component) {\n      throw Error(`Component for ${this.name} has already been provided`);\n    }\n    this.component = component;\n    // return early without attempting to initialize the component if the component requires explicit initialization (calling `Provider.initialize()`)\n    if (!this.shouldAutoInitialize()) {\n      return;\n    }\n    // if the service is eager, initialize the default instance\n    if (isComponentEager(component)) {\n      try {\n        this.getOrInitializeService({\n          instanceIdentifier: DEFAULT_ENTRY_NAME\n        });\n      } catch (e) {\n        // when the instance factory for an eager Component throws an exception during the eager\n        // initialization, it should not cause a fatal error.\n        // TODO: Investigate if we need to make it configurable, because some component may want to cause\n        // a fatal error in this case?\n      }\n    }\n    // Create service instances for the pending promises and resolve them\n    // NOTE: if this.multipleInstances is false, only the default instance will be created\n    // and all promises with resolve with it regardless of the identifier.\n    for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) {\n      const normalizedIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier);\n      try {\n        // `getOrInitializeService()` should always return a valid instance since a component is guaranteed. use ! to make typescript happy.\n        const instance = this.getOrInitializeService({\n          instanceIdentifier: normalizedIdentifier\n        });\n        instanceDeferred.resolve(instance);\n      } catch (e) {\n        // when the instance factory throws an exception, it should not cause\n        // a fatal error. We just leave the promise unresolved.\n      }\n    }\n  }\n  clearInstance(identifier = DEFAULT_ENTRY_NAME) {\n    this.instancesDeferred.delete(identifier);\n    this.instancesOptions.delete(identifier);\n    this.instances.delete(identifier);\n  }\n  // app.delete() will call this method on every provider to delete the services\n  // TODO: should we mark the provider as deleted?\n  async delete() {\n    const services = Array.from(this.instances.values());\n    await Promise.all([...services.filter(service => 'INTERNAL' in service) // legacy services\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    .map(service => service.INTERNAL.delete()), ...services.filter(service => '_delete' in service) // modularized services\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    .map(service => service._delete())]);\n  }\n  isComponentSet() {\n    return this.component != null;\n  }\n  isInitialized(identifier = DEFAULT_ENTRY_NAME) {\n    return this.instances.has(identifier);\n  }\n  getOptions(identifier = DEFAULT_ENTRY_NAME) {\n    return this.instancesOptions.get(identifier) || {};\n  }\n  initialize(opts = {}) {\n    const {\n      options = {}\n    } = opts;\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(opts.instanceIdentifier);\n    if (this.isInitialized(normalizedIdentifier)) {\n      throw Error(`${this.name}(${normalizedIdentifier}) has already been initialized`);\n    }\n    if (!this.isComponentSet()) {\n      throw Error(`Component ${this.name} has not been registered yet`);\n    }\n    const instance = this.getOrInitializeService({\n      instanceIdentifier: normalizedIdentifier,\n      options\n    });\n    // resolve any pending promise waiting for the service instance\n    for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) {\n      const normalizedDeferredIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier);\n      if (normalizedIdentifier === normalizedDeferredIdentifier) {\n        instanceDeferred.resolve(instance);\n      }\n    }\n    return instance;\n  }\n  /**\r\n   *\r\n   * @param callback - a function that will be invoked  after the provider has been initialized by calling provider.initialize().\r\n   * The function is invoked SYNCHRONOUSLY, so it should not execute any longrunning tasks in order to not block the program.\r\n   *\r\n   * @param identifier An optional instance identifier\r\n   * @returns a function to unregister the callback\r\n   */\n  onInit(callback, identifier) {\n    var _a;\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);\n    const existingCallbacks = (_a = this.onInitCallbacks.get(normalizedIdentifier)) !== null && _a !== void 0 ? _a : new Set();\n    existingCallbacks.add(callback);\n    this.onInitCallbacks.set(normalizedIdentifier, existingCallbacks);\n    const existingInstance = this.instances.get(normalizedIdentifier);\n    if (existingInstance) {\n      callback(existingInstance, normalizedIdentifier);\n    }\n    return () => {\n      existingCallbacks.delete(callback);\n    };\n  }\n  /**\r\n   * Invoke onInit callbacks synchronously\r\n   * @param instance the service instance`\r\n   */\n  invokeOnInitCallbacks(instance, identifier) {\n    const callbacks = this.onInitCallbacks.get(identifier);\n    if (!callbacks) {\n      return;\n    }\n    for (const callback of callbacks) {\n      try {\n        callback(instance, identifier);\n      } catch (_a) {\n        // ignore errors in the onInit callback\n      }\n    }\n  }\n  getOrInitializeService({\n    instanceIdentifier,\n    options = {}\n  }) {\n    let instance = this.instances.get(instanceIdentifier);\n    if (!instance && this.component) {\n      instance = this.component.instanceFactory(this.container, {\n        instanceIdentifier: normalizeIdentifierForFactory(instanceIdentifier),\n        options\n      });\n      this.instances.set(instanceIdentifier, instance);\n      this.instancesOptions.set(instanceIdentifier, options);\n      /**\r\n       * Invoke onInit listeners.\r\n       * Note this.component.onInstanceCreated is different, which is used by the component creator,\r\n       * while onInit listeners are registered by consumers of the provider.\r\n       */\n      this.invokeOnInitCallbacks(instance, instanceIdentifier);\n      /**\r\n       * Order is important\r\n       * onInstanceCreated() should be called after this.instances.set(instanceIdentifier, instance); which\r\n       * makes `isInitialized()` return true.\r\n       */\n      if (this.component.onInstanceCreated) {\n        try {\n          this.component.onInstanceCreated(this.container, instanceIdentifier, instance);\n        } catch (_a) {\n          // ignore errors in the onInstanceCreatedCallback\n        }\n      }\n    }\n    return instance || null;\n  }\n  normalizeInstanceIdentifier(identifier = DEFAULT_ENTRY_NAME) {\n    if (this.component) {\n      return this.component.multipleInstances ? identifier : DEFAULT_ENTRY_NAME;\n    } else {\n      return identifier; // assume multiple instances are supported before the component is provided.\n    }\n  }\n  shouldAutoInitialize() {\n    return !!this.component && this.component.instantiationMode !== \"EXPLICIT\" /* InstantiationMode.EXPLICIT */;\n  }\n}\n// undefined should be passed to the service factory for the default instance\nfunction normalizeIdentifierForFactory(identifier) {\n  return identifier === DEFAULT_ENTRY_NAME ? undefined : identifier;\n}\nfunction isComponentEager(component) {\n  return component.instantiationMode === \"EAGER\" /* InstantiationMode.EAGER */;\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * ComponentContainer that provides Providers for service name T, e.g. `auth`, `auth-internal`\r\n */\nclass ComponentContainer {\n  constructor(name) {\n    this.name = name;\n    this.providers = new Map();\n  }\n  /**\r\n   *\r\n   * @param component Component being added\r\n   * @param overwrite When a component with the same name has already been registered,\r\n   * if overwrite is true: overwrite the existing component with the new component and create a new\r\n   * provider with the new component. It can be useful in tests where you want to use different mocks\r\n   * for different tests.\r\n   * if overwrite is false: throw an exception\r\n   */\n  addComponent(component) {\n    const provider = this.getProvider(component.name);\n    if (provider.isComponentSet()) {\n      throw new Error(`Component ${component.name} has already been registered with ${this.name}`);\n    }\n    provider.setComponent(component);\n  }\n  addOrOverwriteComponent(component) {\n    const provider = this.getProvider(component.name);\n    if (provider.isComponentSet()) {\n      // delete the existing provider from the container, so we can register the new component\n      this.providers.delete(component.name);\n    }\n    this.addComponent(component);\n  }\n  /**\r\n   * getProvider provides a type safe interface where it can only be called with a field name\r\n   * present in NameServiceMapping interface.\r\n   *\r\n   * Firebase SDKs providing services should extend NameServiceMapping interface to register\r\n   * themselves.\r\n   */\n  getProvider(name) {\n    if (this.providers.has(name)) {\n      return this.providers.get(name);\n    }\n    // create a Provider for a service that hasn't registered with Firebase\n    const provider = new Provider(name, this);\n    this.providers.set(name, provider);\n    return provider;\n  }\n  getProviders() {\n    return Array.from(this.providers.values());\n  }\n}\nexport { Component, ComponentContainer, Provider };\n","/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * A container for all of the Logger instances\r\n */\nconst instances = [];\n/**\r\n * The JS SDK supports 5 log levels and also allows a user the ability to\r\n * silence the logs altogether.\r\n *\r\n * The order is a follows:\r\n * DEBUG < VERBOSE < INFO < WARN < ERROR\r\n *\r\n * All of the log types above the current log level will be captured (i.e. if\r\n * you set the log level to `INFO`, errors will still be logged, but `DEBUG` and\r\n * `VERBOSE` logs will not)\r\n */\nvar LogLevel = /*#__PURE__*/function (LogLevel) {\n  LogLevel[LogLevel[\"DEBUG\"] = 0] = \"DEBUG\";\n  LogLevel[LogLevel[\"VERBOSE\"] = 1] = \"VERBOSE\";\n  LogLevel[LogLevel[\"INFO\"] = 2] = \"INFO\";\n  LogLevel[LogLevel[\"WARN\"] = 3] = \"WARN\";\n  LogLevel[LogLevel[\"ERROR\"] = 4] = \"ERROR\";\n  LogLevel[LogLevel[\"SILENT\"] = 5] = \"SILENT\";\n  return LogLevel;\n}(LogLevel || {});\nconst levelStringToEnum = {\n  'debug': LogLevel.DEBUG,\n  'verbose': LogLevel.VERBOSE,\n  'info': LogLevel.INFO,\n  'warn': LogLevel.WARN,\n  'error': LogLevel.ERROR,\n  'silent': LogLevel.SILENT\n};\n/**\r\n * The default log level\r\n */\nconst defaultLogLevel = LogLevel.INFO;\n/**\r\n * By default, `console.debug` is not displayed in the developer console (in\r\n * chrome). To avoid forcing users to have to opt-in to these logs twice\r\n * (i.e. once for firebase, and once in the console), we are sending `DEBUG`\r\n * logs to the `console.log` function.\r\n */\nconst ConsoleMethod = {\n  [LogLevel.DEBUG]: 'log',\n  [LogLevel.VERBOSE]: 'log',\n  [LogLevel.INFO]: 'info',\n  [LogLevel.WARN]: 'warn',\n  [LogLevel.ERROR]: 'error'\n};\n/**\r\n * The default log handler will forward DEBUG, VERBOSE, INFO, WARN, and ERROR\r\n * messages on to their corresponding console counterparts (if the log method\r\n * is supported by the current log level)\r\n */\nconst defaultLogHandler = (instance, logType, ...args) => {\n  if (logType < instance.logLevel) {\n    return;\n  }\n  const now = new Date().toISOString();\n  const method = ConsoleMethod[logType];\n  if (method) {\n    console[method](`[${now}]  ${instance.name}:`, ...args);\n  } else {\n    throw new Error(`Attempted to log a message with an invalid logType (value: ${logType})`);\n  }\n};\nclass Logger {\n  /**\r\n   * Gives you an instance of a Logger to capture messages according to\r\n   * Firebase's logging scheme.\r\n   *\r\n   * @param name The name that the logs will be associated with\r\n   */\n  constructor(name) {\n    this.name = name;\n    /**\r\n     * The log level of the given Logger instance.\r\n     */\n    this._logLevel = defaultLogLevel;\n    /**\r\n     * The main (internal) log handler for the Logger instance.\r\n     * Can be set to a new function in internal package code but not by user.\r\n     */\n    this._logHandler = defaultLogHandler;\n    /**\r\n     * The optional, additional, user-defined log handler for the Logger instance.\r\n     */\n    this._userLogHandler = null;\n    /**\r\n     * Capture the current instance for later use\r\n     */\n    instances.push(this);\n  }\n  get logLevel() {\n    return this._logLevel;\n  }\n  set logLevel(val) {\n    if (!(val in LogLevel)) {\n      throw new TypeError(`Invalid value \"${val}\" assigned to \\`logLevel\\``);\n    }\n    this._logLevel = val;\n  }\n  // Workaround for setter/getter having to be the same type.\n  setLogLevel(val) {\n    this._logLevel = typeof val === 'string' ? levelStringToEnum[val] : val;\n  }\n  get logHandler() {\n    return this._logHandler;\n  }\n  set logHandler(val) {\n    if (typeof val !== 'function') {\n      throw new TypeError('Value assigned to `logHandler` must be a function');\n    }\n    this._logHandler = val;\n  }\n  get userLogHandler() {\n    return this._userLogHandler;\n  }\n  set userLogHandler(val) {\n    this._userLogHandler = val;\n  }\n  /**\r\n   * The functions below are all based on the `console` interface\r\n   */\n  debug(...args) {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.DEBUG, ...args);\n    this._logHandler(this, LogLevel.DEBUG, ...args);\n  }\n  log(...args) {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.VERBOSE, ...args);\n    this._logHandler(this, LogLevel.VERBOSE, ...args);\n  }\n  info(...args) {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.INFO, ...args);\n    this._logHandler(this, LogLevel.INFO, ...args);\n  }\n  warn(...args) {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.WARN, ...args);\n    this._logHandler(this, LogLevel.WARN, ...args);\n  }\n  error(...args) {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.ERROR, ...args);\n    this._logHandler(this, LogLevel.ERROR, ...args);\n  }\n}\nfunction setLogLevel(level) {\n  instances.forEach(inst => {\n    inst.setLogLevel(level);\n  });\n}\nfunction setUserLogHandler(logCallback, options) {\n  for (const instance of instances) {\n    let customLogLevel = null;\n    if (options && options.level) {\n      customLogLevel = levelStringToEnum[options.level];\n    }\n    if (logCallback === null) {\n      instance.userLogHandler = null;\n    } else {\n      instance.userLogHandler = (instance, level, ...args) => {\n        const message = args.map(arg => {\n          if (arg == null) {\n            return null;\n          } else if (typeof arg === 'string') {\n            return arg;\n          } else if (typeof arg === 'number' || typeof arg === 'boolean') {\n            return arg.toString();\n          } else if (arg instanceof Error) {\n            return arg.message;\n          } else {\n            try {\n              return JSON.stringify(arg);\n            } catch (ignored) {\n              return null;\n            }\n          }\n        }).filter(arg => arg).join(' ');\n        if (level >= (customLogLevel !== null && customLogLevel !== void 0 ? customLogLevel : instance.logLevel)) {\n          logCallback({\n            level: LogLevel[level].toLowerCase(),\n            message,\n            args,\n            type: instance.name\n          });\n        }\n      };\n    }\n  }\n}\nexport { LogLevel, Logger, setLogLevel, setUserLogHandler };\n","import { Component, ComponentContainer } from '@firebase/component';\nimport { Logger, setUserLogHandler, setLogLevel as setLogLevel$1 } from '@firebase/logger';\nimport { ErrorFactory, getDefaultAppConfig, deepEqual, FirebaseError, base64urlEncodeWithoutPadding, isIndexedDBAvailable, validateIndexedDBOpenable } from '@firebase/util';\nexport { FirebaseError } from '@firebase/util';\nimport { openDB } from 'idb';\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nclass PlatformLoggerServiceImpl {\n  constructor(container) {\n    this.container = container;\n  }\n  // In initial implementation, this will be called by installations on\n  // auth token refresh, and installations will send this string.\n  getPlatformInfoString() {\n    const providers = this.container.getProviders();\n    // Loop through providers and get library/version pairs from any that are\n    // version components.\n    return providers.map(provider => {\n      if (isVersionServiceProvider(provider)) {\n        const service = provider.getImmediate();\n        return `${service.library}/${service.version}`;\n      } else {\n        return null;\n      }\n    }).filter(logString => logString).join(' ');\n  }\n}\n/**\r\n *\r\n * @param provider check if this provider provides a VersionService\r\n *\r\n * NOTE: Using Provider<'app-version'> is a hack to indicate that the provider\r\n * provides VersionService. The provider is not necessarily a 'app-version'\r\n * provider.\r\n */\nfunction isVersionServiceProvider(provider) {\n  const component = provider.getComponent();\n  return (component === null || component === void 0 ? void 0 : component.type) === \"VERSION\" /* ComponentType.VERSION */;\n}\nconst name$o = \"@firebase/app\";\nconst version$1 = \"0.9.25\";\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nconst logger = new Logger('@firebase/app');\nconst name$n = \"@firebase/app-compat\";\nconst name$m = \"@firebase/analytics-compat\";\nconst name$l = \"@firebase/analytics\";\nconst name$k = \"@firebase/app-check-compat\";\nconst name$j = \"@firebase/app-check\";\nconst name$i = \"@firebase/auth\";\nconst name$h = \"@firebase/auth-compat\";\nconst name$g = \"@firebase/database\";\nconst name$f = \"@firebase/database-compat\";\nconst name$e = \"@firebase/functions\";\nconst name$d = \"@firebase/functions-compat\";\nconst name$c = \"@firebase/installations\";\nconst name$b = \"@firebase/installations-compat\";\nconst name$a = \"@firebase/messaging\";\nconst name$9 = \"@firebase/messaging-compat\";\nconst name$8 = \"@firebase/performance\";\nconst name$7 = \"@firebase/performance-compat\";\nconst name$6 = \"@firebase/remote-config\";\nconst name$5 = \"@firebase/remote-config-compat\";\nconst name$4 = \"@firebase/storage\";\nconst name$3 = \"@firebase/storage-compat\";\nconst name$2 = \"@firebase/firestore\";\nconst name$1 = \"@firebase/firestore-compat\";\nconst name = \"firebase\";\nconst version = \"10.7.1\";\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * The default app name\r\n *\r\n * @internal\r\n */\nconst DEFAULT_ENTRY_NAME = '[DEFAULT]';\nconst PLATFORM_LOG_STRING = {\n  [name$o]: 'fire-core',\n  [name$n]: 'fire-core-compat',\n  [name$l]: 'fire-analytics',\n  [name$m]: 'fire-analytics-compat',\n  [name$j]: 'fire-app-check',\n  [name$k]: 'fire-app-check-compat',\n  [name$i]: 'fire-auth',\n  [name$h]: 'fire-auth-compat',\n  [name$g]: 'fire-rtdb',\n  [name$f]: 'fire-rtdb-compat',\n  [name$e]: 'fire-fn',\n  [name$d]: 'fire-fn-compat',\n  [name$c]: 'fire-iid',\n  [name$b]: 'fire-iid-compat',\n  [name$a]: 'fire-fcm',\n  [name$9]: 'fire-fcm-compat',\n  [name$8]: 'fire-perf',\n  [name$7]: 'fire-perf-compat',\n  [name$6]: 'fire-rc',\n  [name$5]: 'fire-rc-compat',\n  [name$4]: 'fire-gcs',\n  [name$3]: 'fire-gcs-compat',\n  [name$2]: 'fire-fst',\n  [name$1]: 'fire-fst-compat',\n  'fire-js': 'fire-js',\n  [name]: 'fire-js-all'\n};\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * @internal\r\n */\nconst _apps = new Map();\n/**\r\n * Registered components.\r\n *\r\n * @internal\r\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst _components = new Map();\n/**\r\n * @param component - the component being added to this app's container\r\n *\r\n * @internal\r\n */\nfunction _addComponent(app, component) {\n  try {\n    app.container.addComponent(component);\n  } catch (e) {\n    logger.debug(`Component ${component.name} failed to register with FirebaseApp ${app.name}`, e);\n  }\n}\n/**\r\n *\r\n * @internal\r\n */\nfunction _addOrOverwriteComponent(app, component) {\n  app.container.addOrOverwriteComponent(component);\n}\n/**\r\n *\r\n * @param component - the component to register\r\n * @returns whether or not the component is registered successfully\r\n *\r\n * @internal\r\n */\nfunction _registerComponent(component) {\n  const componentName = component.name;\n  if (_components.has(componentName)) {\n    logger.debug(`There were multiple attempts to register component ${componentName}.`);\n    return false;\n  }\n  _components.set(componentName, component);\n  // add the component to existing app instances\n  for (const app of _apps.values()) {\n    _addComponent(app, component);\n  }\n  return true;\n}\n/**\r\n *\r\n * @param app - FirebaseApp instance\r\n * @param name - service name\r\n *\r\n * @returns the provider for the service with the matching name\r\n *\r\n * @internal\r\n */\nfunction _getProvider(app, name) {\n  const heartbeatController = app.container.getProvider('heartbeat').getImmediate({\n    optional: true\n  });\n  if (heartbeatController) {\n    void heartbeatController.triggerHeartbeat();\n  }\n  return app.container.getProvider(name);\n}\n/**\r\n *\r\n * @param app - FirebaseApp instance\r\n * @param name - service name\r\n * @param instanceIdentifier - service instance identifier in case the service supports multiple instances\r\n *\r\n * @internal\r\n */\nfunction _removeServiceInstance(app, name, instanceIdentifier = DEFAULT_ENTRY_NAME) {\n  _getProvider(app, name).clearInstance(instanceIdentifier);\n}\n/**\r\n * Test only\r\n *\r\n * @internal\r\n */\nfunction _clearComponents() {\n  _components.clear();\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nconst ERRORS = {\n  [\"no-app\" /* AppError.NO_APP */]: \"No Firebase App '{$appName}' has been created - \" + 'call initializeApp() first',\n  [\"bad-app-name\" /* AppError.BAD_APP_NAME */]: \"Illegal App name: '{$appName}\",\n  [\"duplicate-app\" /* AppError.DUPLICATE_APP */]: \"Firebase App named '{$appName}' already exists with different options or config\",\n  [\"app-deleted\" /* AppError.APP_DELETED */]: \"Firebase App named '{$appName}' already deleted\",\n  [\"no-options\" /* AppError.NO_OPTIONS */]: 'Need to provide options, when not being deployed to hosting via source.',\n  [\"invalid-app-argument\" /* AppError.INVALID_APP_ARGUMENT */]: 'firebase.{$appName}() takes either no argument or a ' + 'Firebase App instance.',\n  [\"invalid-log-argument\" /* AppError.INVALID_LOG_ARGUMENT */]: 'First argument to `onLog` must be null or a function.',\n  [\"idb-open\" /* AppError.IDB_OPEN */]: 'Error thrown when opening IndexedDB. Original error: {$originalErrorMessage}.',\n  [\"idb-get\" /* AppError.IDB_GET */]: 'Error thrown when reading from IndexedDB. Original error: {$originalErrorMessage}.',\n  [\"idb-set\" /* AppError.IDB_WRITE */]: 'Error thrown when writing to IndexedDB. Original error: {$originalErrorMessage}.',\n  [\"idb-delete\" /* AppError.IDB_DELETE */]: 'Error thrown when deleting from IndexedDB. Original error: {$originalErrorMessage}.'\n};\nconst ERROR_FACTORY = new ErrorFactory('app', 'Firebase', ERRORS);\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nclass FirebaseAppImpl {\n  constructor(options, config, container) {\n    this._isDeleted = false;\n    this._options = Object.assign({}, options);\n    this._config = Object.assign({}, config);\n    this._name = config.name;\n    this._automaticDataCollectionEnabled = config.automaticDataCollectionEnabled;\n    this._container = container;\n    this.container.addComponent(new Component('app', () => this, \"PUBLIC\" /* ComponentType.PUBLIC */));\n  }\n  get automaticDataCollectionEnabled() {\n    this.checkDestroyed();\n    return this._automaticDataCollectionEnabled;\n  }\n  set automaticDataCollectionEnabled(val) {\n    this.checkDestroyed();\n    this._automaticDataCollectionEnabled = val;\n  }\n  get name() {\n    this.checkDestroyed();\n    return this._name;\n  }\n  get options() {\n    this.checkDestroyed();\n    return this._options;\n  }\n  get config() {\n    this.checkDestroyed();\n    return this._config;\n  }\n  get container() {\n    return this._container;\n  }\n  get isDeleted() {\n    return this._isDeleted;\n  }\n  set isDeleted(val) {\n    this._isDeleted = val;\n  }\n  /**\r\n   * This function will throw an Error if the App has already been deleted -\r\n   * use before performing API actions on the App.\r\n   */\n  checkDestroyed() {\n    if (this.isDeleted) {\n      throw ERROR_FACTORY.create(\"app-deleted\" /* AppError.APP_DELETED */, {\n        appName: this._name\n      });\n    }\n  }\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n/**\r\n * The current SDK version.\r\n *\r\n * @public\r\n */\nconst SDK_VERSION = version;\nfunction initializeApp(_options, rawConfig = {}) {\n  let options = _options;\n  if (typeof rawConfig !== 'object') {\n    const name = rawConfig;\n    rawConfig = {\n      name\n    };\n  }\n  const config = Object.assign({\n    name: DEFAULT_ENTRY_NAME,\n    automaticDataCollectionEnabled: false\n  }, rawConfig);\n  const name = config.name;\n  if (typeof name !== 'string' || !name) {\n    throw ERROR_FACTORY.create(\"bad-app-name\" /* AppError.BAD_APP_NAME */, {\n      appName: String(name)\n    });\n  }\n  options || (options = getDefaultAppConfig());\n  if (!options) {\n    throw ERROR_FACTORY.create(\"no-options\" /* AppError.NO_OPTIONS */);\n  }\n  const existingApp = _apps.get(name);\n  if (existingApp) {\n    // return the existing app if options and config deep equal the ones in the existing app.\n    if (deepEqual(options, existingApp.options) && deepEqual(config, existingApp.config)) {\n      return existingApp;\n    } else {\n      throw ERROR_FACTORY.create(\"duplicate-app\" /* AppError.DUPLICATE_APP */, {\n        appName: name\n      });\n    }\n  }\n  const container = new ComponentContainer(name);\n  for (const component of _components.values()) {\n    container.addComponent(component);\n  }\n  const newApp = new FirebaseAppImpl(options, config, container);\n  _apps.set(name, newApp);\n  return newApp;\n}\n/**\r\n * Retrieves a {@link @firebase/app#FirebaseApp} instance.\r\n *\r\n * When called with no arguments, the default app is returned. When an app name\r\n * is provided, the app corresponding to that name is returned.\r\n *\r\n * An exception is thrown if the app being retrieved has not yet been\r\n * initialized.\r\n *\r\n * @example\r\n * ```javascript\r\n * // Return the default app\r\n * const app = getApp();\r\n * ```\r\n *\r\n * @example\r\n * ```javascript\r\n * // Return a named app\r\n * const otherApp = getApp(\"otherApp\");\r\n * ```\r\n *\r\n * @param name - Optional name of the app to return. If no name is\r\n *   provided, the default is `\"[DEFAULT]\"`.\r\n *\r\n * @returns The app corresponding to the provided app name.\r\n *   If no app name is provided, the default app is returned.\r\n *\r\n * @public\r\n */\nfunction getApp(name = DEFAULT_ENTRY_NAME) {\n  const app = _apps.get(name);\n  if (!app && name === DEFAULT_ENTRY_NAME && getDefaultAppConfig()) {\n    return initializeApp();\n  }\n  if (!app) {\n    throw ERROR_FACTORY.create(\"no-app\" /* AppError.NO_APP */, {\n      appName: name\n    });\n  }\n  return app;\n}\n/**\r\n * A (read-only) array of all initialized apps.\r\n * @public\r\n */\nfunction getApps() {\n  return Array.from(_apps.values());\n}\n/**\r\n * Renders this app unusable and frees the resources of all associated\r\n * services.\r\n *\r\n * @example\r\n * ```javascript\r\n * deleteApp(app)\r\n *   .then(function() {\r\n *     console.log(\"App deleted successfully\");\r\n *   })\r\n *   .catch(function(error) {\r\n *     console.log(\"Error deleting app:\", error);\r\n *   });\r\n * ```\r\n *\r\n * @public\r\n */\nasync function deleteApp(app) {\n  const name = app.name;\n  if (_apps.has(name)) {\n    _apps.delete(name);\n    await Promise.all(app.container.getProviders().map(provider => provider.delete()));\n    app.isDeleted = true;\n  }\n}\n/**\r\n * Registers a library's name and version for platform logging purposes.\r\n * @param library - Name of 1p or 3p library (e.g. firestore, angularfire)\r\n * @param version - Current version of that library.\r\n * @param variant - Bundle variant, e.g., node, rn, etc.\r\n *\r\n * @public\r\n */\nfunction registerVersion(libraryKeyOrName, version, variant) {\n  var _a;\n  // TODO: We can use this check to whitelist strings when/if we set up\n  // a good whitelist system.\n  let library = (_a = PLATFORM_LOG_STRING[libraryKeyOrName]) !== null && _a !== void 0 ? _a : libraryKeyOrName;\n  if (variant) {\n    library += `-${variant}`;\n  }\n  const libraryMismatch = library.match(/\\s|\\//);\n  const versionMismatch = version.match(/\\s|\\//);\n  if (libraryMismatch || versionMismatch) {\n    const warning = [`Unable to register library \"${library}\" with version \"${version}\":`];\n    if (libraryMismatch) {\n      warning.push(`library name \"${library}\" contains illegal characters (whitespace or \"/\")`);\n    }\n    if (libraryMismatch && versionMismatch) {\n      warning.push('and');\n    }\n    if (versionMismatch) {\n      warning.push(`version name \"${version}\" contains illegal characters (whitespace or \"/\")`);\n    }\n    logger.warn(warning.join(' '));\n    return;\n  }\n  _registerComponent(new Component(`${library}-version`, () => ({\n    library,\n    version\n  }), \"VERSION\" /* ComponentType.VERSION */));\n}\n/**\r\n * Sets log handler for all Firebase SDKs.\r\n * @param logCallback - An optional custom log handler that executes user code whenever\r\n * the Firebase SDK makes a logging call.\r\n *\r\n * @public\r\n */\nfunction onLog(logCallback, options) {\n  if (logCallback !== null && typeof logCallback !== 'function') {\n    throw ERROR_FACTORY.create(\"invalid-log-argument\" /* AppError.INVALID_LOG_ARGUMENT */);\n  }\n  setUserLogHandler(logCallback, options);\n}\n/**\r\n * Sets log level for all Firebase SDKs.\r\n *\r\n * All of the log types above the current log level are captured (i.e. if\r\n * you set the log level to `info`, errors are logged, but `debug` and\r\n * `verbose` logs are not).\r\n *\r\n * @public\r\n */\nfunction setLogLevel(logLevel) {\n  setLogLevel$1(logLevel);\n}\n\n/**\r\n * @license\r\n * Copyright 2021 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nconst DB_NAME = 'firebase-heartbeat-database';\nconst DB_VERSION = 1;\nconst STORE_NAME = 'firebase-heartbeat-store';\nlet dbPromise = null;\nfunction getDbPromise() {\n  if (!dbPromise) {\n    dbPromise = openDB(DB_NAME, DB_VERSION, {\n      upgrade: (db, oldVersion) => {\n        // We don't use 'break' in this switch statement, the fall-through\n        // behavior is what we want, because if there are multiple versions between\n        // the old version and the current version, we want ALL the migrations\n        // that correspond to those versions to run, not only the last one.\n        // eslint-disable-next-line default-case\n        switch (oldVersion) {\n          case 0:\n            db.createObjectStore(STORE_NAME);\n        }\n      }\n    }).catch(e => {\n      throw ERROR_FACTORY.create(\"idb-open\" /* AppError.IDB_OPEN */, {\n        originalErrorMessage: e.message\n      });\n    });\n  }\n  return dbPromise;\n}\nasync function readHeartbeatsFromIndexedDB(app) {\n  try {\n    const db = await getDbPromise();\n    const result = await db.transaction(STORE_NAME).objectStore(STORE_NAME).get(computeKey(app));\n    return result;\n  } catch (e) {\n    if (e instanceof FirebaseError) {\n      logger.warn(e.message);\n    } else {\n      const idbGetError = ERROR_FACTORY.create(\"idb-get\" /* AppError.IDB_GET */, {\n        originalErrorMessage: e === null || e === void 0 ? void 0 : e.message\n      });\n      logger.warn(idbGetError.message);\n    }\n  }\n}\nasync function writeHeartbeatsToIndexedDB(app, heartbeatObject) {\n  try {\n    const db = await getDbPromise();\n    const tx = db.transaction(STORE_NAME, 'readwrite');\n    const objectStore = tx.objectStore(STORE_NAME);\n    await objectStore.put(heartbeatObject, computeKey(app));\n    await tx.done;\n  } catch (e) {\n    if (e instanceof FirebaseError) {\n      logger.warn(e.message);\n    } else {\n      const idbGetError = ERROR_FACTORY.create(\"idb-set\" /* AppError.IDB_WRITE */, {\n        originalErrorMessage: e === null || e === void 0 ? void 0 : e.message\n      });\n      logger.warn(idbGetError.message);\n    }\n  }\n}\nfunction computeKey(app) {\n  return `${app.name}!${app.options.appId}`;\n}\n\n/**\r\n * @license\r\n * Copyright 2021 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nconst MAX_HEADER_BYTES = 1024;\n// 30 days\nconst STORED_HEARTBEAT_RETENTION_MAX_MILLIS = 30 * 24 * 60 * 60 * 1000;\nclass HeartbeatServiceImpl {\n  constructor(container) {\n    this.container = container;\n    /**\r\n     * In-memory cache for heartbeats, used by getHeartbeatsHeader() to generate\r\n     * the header string.\r\n     * Stores one record per date. This will be consolidated into the standard\r\n     * format of one record per user agent string before being sent as a header.\r\n     * Populated from indexedDB when the controller is instantiated and should\r\n     * be kept in sync with indexedDB.\r\n     * Leave public for easier testing.\r\n     */\n    this._heartbeatsCache = null;\n    const app = this.container.getProvider('app').getImmediate();\n    this._storage = new HeartbeatStorageImpl(app);\n    this._heartbeatsCachePromise = this._storage.read().then(result => {\n      this._heartbeatsCache = result;\n      return result;\n    });\n  }\n  /**\r\n   * Called to report a heartbeat. The function will generate\r\n   * a HeartbeatsByUserAgent object, update heartbeatsCache, and persist it\r\n   * to IndexedDB.\r\n   * Note that we only store one heartbeat per day. So if a heartbeat for today is\r\n   * already logged, subsequent calls to this function in the same day will be ignored.\r\n   */\n  async triggerHeartbeat() {\n    var _a, _b;\n    const platformLogger = this.container.getProvider('platform-logger').getImmediate();\n    // This is the \"Firebase user agent\" string from the platform logger\n    // service, not the browser user agent.\n    const agent = platformLogger.getPlatformInfoString();\n    const date = getUTCDateString();\n    if (((_a = this._heartbeatsCache) === null || _a === void 0 ? void 0 : _a.heartbeats) == null) {\n      this._heartbeatsCache = await this._heartbeatsCachePromise;\n      // If we failed to construct a heartbeats cache, then return immediately.\n      if (((_b = this._heartbeatsCache) === null || _b === void 0 ? void 0 : _b.heartbeats) == null) {\n        return;\n      }\n    }\n    // Do not store a heartbeat if one is already stored for this day\n    // or if a header has already been sent today.\n    if (this._heartbeatsCache.lastSentHeartbeatDate === date || this._heartbeatsCache.heartbeats.some(singleDateHeartbeat => singleDateHeartbeat.date === date)) {\n      return;\n    } else {\n      // There is no entry for this date. Create one.\n      this._heartbeatsCache.heartbeats.push({\n        date,\n        agent\n      });\n    }\n    // Remove entries older than 30 days.\n    this._heartbeatsCache.heartbeats = this._heartbeatsCache.heartbeats.filter(singleDateHeartbeat => {\n      const hbTimestamp = new Date(singleDateHeartbeat.date).valueOf();\n      const now = Date.now();\n      return now - hbTimestamp <= STORED_HEARTBEAT_RETENTION_MAX_MILLIS;\n    });\n    return this._storage.overwrite(this._heartbeatsCache);\n  }\n  /**\r\n   * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly.\r\n   * It also clears all heartbeats from memory as well as in IndexedDB.\r\n   *\r\n   * NOTE: Consuming product SDKs should not send the header if this method\r\n   * returns an empty string.\r\n   */\n  async getHeartbeatsHeader() {\n    var _a;\n    if (this._heartbeatsCache === null) {\n      await this._heartbeatsCachePromise;\n    }\n    // If it's still null or the array is empty, there is no data to send.\n    if (((_a = this._heartbeatsCache) === null || _a === void 0 ? void 0 : _a.heartbeats) == null || this._heartbeatsCache.heartbeats.length === 0) {\n      return '';\n    }\n    const date = getUTCDateString();\n    // Extract as many heartbeats from the cache as will fit under the size limit.\n    const {\n      heartbeatsToSend,\n      unsentEntries\n    } = extractHeartbeatsForHeader(this._heartbeatsCache.heartbeats);\n    const headerString = base64urlEncodeWithoutPadding(JSON.stringify({\n      version: 2,\n      heartbeats: heartbeatsToSend\n    }));\n    // Store last sent date to prevent another being logged/sent for the same day.\n    this._heartbeatsCache.lastSentHeartbeatDate = date;\n    if (unsentEntries.length > 0) {\n      // Store any unsent entries if they exist.\n      this._heartbeatsCache.heartbeats = unsentEntries;\n      // This seems more likely than emptying the array (below) to lead to some odd state\n      // since the cache isn't empty and this will be called again on the next request,\n      // and is probably safest if we await it.\n      await this._storage.overwrite(this._heartbeatsCache);\n    } else {\n      this._heartbeatsCache.heartbeats = [];\n      // Do not wait for this, to reduce latency.\n      void this._storage.overwrite(this._heartbeatsCache);\n    }\n    return headerString;\n  }\n}\nfunction getUTCDateString() {\n  const today = new Date();\n  // Returns date format 'YYYY-MM-DD'\n  return today.toISOString().substring(0, 10);\n}\nfunction extractHeartbeatsForHeader(heartbeatsCache, maxSize = MAX_HEADER_BYTES) {\n  // Heartbeats grouped by user agent in the standard format to be sent in\n  // the header.\n  const heartbeatsToSend = [];\n  // Single date format heartbeats that are not sent.\n  let unsentEntries = heartbeatsCache.slice();\n  for (const singleDateHeartbeat of heartbeatsCache) {\n    // Look for an existing entry with the same user agent.\n    const heartbeatEntry = heartbeatsToSend.find(hb => hb.agent === singleDateHeartbeat.agent);\n    if (!heartbeatEntry) {\n      // If no entry for this user agent exists, create one.\n      heartbeatsToSend.push({\n        agent: singleDateHeartbeat.agent,\n        dates: [singleDateHeartbeat.date]\n      });\n      if (countBytes(heartbeatsToSend) > maxSize) {\n        // If the header would exceed max size, remove the added heartbeat\n        // entry and stop adding to the header.\n        heartbeatsToSend.pop();\n        break;\n      }\n    } else {\n      heartbeatEntry.dates.push(singleDateHeartbeat.date);\n      // If the header would exceed max size, remove the added date\n      // and stop adding to the header.\n      if (countBytes(heartbeatsToSend) > maxSize) {\n        heartbeatEntry.dates.pop();\n        break;\n      }\n    }\n    // Pop unsent entry from queue. (Skipped if adding the entry exceeded\n    // quota and the loop breaks early.)\n    unsentEntries = unsentEntries.slice(1);\n  }\n  return {\n    heartbeatsToSend,\n    unsentEntries\n  };\n}\nclass HeartbeatStorageImpl {\n  constructor(app) {\n    this.app = app;\n    this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();\n  }\n  async runIndexedDBEnvironmentCheck() {\n    if (!isIndexedDBAvailable()) {\n      return false;\n    } else {\n      return validateIndexedDBOpenable().then(() => true).catch(() => false);\n    }\n  }\n  /**\r\n   * Read all heartbeats.\r\n   */\n  async read() {\n    const canUseIndexedDB = await this._canUseIndexedDBPromise;\n    if (!canUseIndexedDB) {\n      return {\n        heartbeats: []\n      };\n    } else {\n      const idbHeartbeatObject = await readHeartbeatsFromIndexedDB(this.app);\n      if (idbHeartbeatObject === null || idbHeartbeatObject === void 0 ? void 0 : idbHeartbeatObject.heartbeats) {\n        return idbHeartbeatObject;\n      } else {\n        return {\n          heartbeats: []\n        };\n      }\n    }\n  }\n  // overwrite the storage with the provided heartbeats\n  async overwrite(heartbeatsObject) {\n    var _a;\n    const canUseIndexedDB = await this._canUseIndexedDBPromise;\n    if (!canUseIndexedDB) {\n      return;\n    } else {\n      const existingHeartbeatsObject = await this.read();\n      return writeHeartbeatsToIndexedDB(this.app, {\n        lastSentHeartbeatDate: (_a = heartbeatsObject.lastSentHeartbeatDate) !== null && _a !== void 0 ? _a : existingHeartbeatsObject.lastSentHeartbeatDate,\n        heartbeats: heartbeatsObject.heartbeats\n      });\n    }\n  }\n  // add heartbeats\n  async add(heartbeatsObject) {\n    var _a;\n    const canUseIndexedDB = await this._canUseIndexedDBPromise;\n    if (!canUseIndexedDB) {\n      return;\n    } else {\n      const existingHeartbeatsObject = await this.read();\n      return writeHeartbeatsToIndexedDB(this.app, {\n        lastSentHeartbeatDate: (_a = heartbeatsObject.lastSentHeartbeatDate) !== null && _a !== void 0 ? _a : existingHeartbeatsObject.lastSentHeartbeatDate,\n        heartbeats: [...existingHeartbeatsObject.heartbeats, ...heartbeatsObject.heartbeats]\n      });\n    }\n  }\n}\n/**\r\n * Calculate bytes of a HeartbeatsByUserAgent array after being wrapped\r\n * in a platform logging header JSON object, stringified, and converted\r\n * to base 64.\r\n */\nfunction countBytes(heartbeatsCache) {\n  // base64 has a restricted set of characters, all of which should be 1 byte.\n  return base64urlEncodeWithoutPadding(\n  // heartbeatsCache wrapper properties\n  JSON.stringify({\n    version: 2,\n    heartbeats: heartbeatsCache\n  })).length;\n}\n\n/**\r\n * @license\r\n * Copyright 2019 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\nfunction registerCoreComponents(variant) {\n  _registerComponent(new Component('platform-logger', container => new PlatformLoggerServiceImpl(container), \"PRIVATE\" /* ComponentType.PRIVATE */));\n  _registerComponent(new Component('heartbeat', container => new HeartbeatServiceImpl(container), \"PRIVATE\" /* ComponentType.PRIVATE */));\n  // Register `app` package.\n  registerVersion(name$o, version$1, variant);\n  // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation\n  registerVersion(name$o, version$1, 'esm2017');\n  // Register platform SDK identifier (no version).\n  registerVersion('fire-js', '');\n}\n\n/**\r\n * Firebase App\r\n *\r\n * @remarks This package coordinates the communication between the different Firebase components\r\n * @packageDocumentation\r\n */\nregisterCoreComponents('');\nexport { SDK_VERSION, DEFAULT_ENTRY_NAME as _DEFAULT_ENTRY_NAME, _addComponent, _addOrOverwriteComponent, _apps, _clearComponents, _components, _getProvider, _registerComponent, _removeServiceInstance, deleteApp, getApp, getApps, initializeApp, onLog, registerVersion, setLogLevel };\n","const instanceOfAny = (object, constructors) => constructors.some(c => object instanceof c);\nlet idbProxyableTypes;\nlet cursorAdvanceMethods;\n// This is a function to prevent it throwing up in node environments.\nfunction getIdbProxyableTypes() {\n  return idbProxyableTypes || (idbProxyableTypes = [IDBDatabase, IDBObjectStore, IDBIndex, IDBCursor, IDBTransaction]);\n}\n// This is a function to prevent it throwing up in node environments.\nfunction getCursorAdvanceMethods() {\n  return cursorAdvanceMethods || (cursorAdvanceMethods = [IDBCursor.prototype.advance, IDBCursor.prototype.continue, IDBCursor.prototype.continuePrimaryKey]);\n}\nconst cursorRequestMap = new WeakMap();\nconst transactionDoneMap = new WeakMap();\nconst transactionStoreNamesMap = new WeakMap();\nconst transformCache = new WeakMap();\nconst reverseTransformCache = new WeakMap();\nfunction promisifyRequest(request) {\n  const promise = new Promise((resolve, reject) => {\n    const unlisten = () => {\n      request.removeEventListener('success', success);\n      request.removeEventListener('error', error);\n    };\n    const success = () => {\n      resolve(wrap(request.result));\n      unlisten();\n    };\n    const error = () => {\n      reject(request.error);\n      unlisten();\n    };\n    request.addEventListener('success', success);\n    request.addEventListener('error', error);\n  });\n  promise.then(value => {\n    // Since cursoring reuses the IDBRequest (*sigh*), we cache it for later retrieval\n    // (see wrapFunction).\n    if (value instanceof IDBCursor) {\n      cursorRequestMap.set(value, request);\n    }\n    // Catching to avoid \"Uncaught Promise exceptions\"\n  }).catch(() => {});\n  // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This\n  // is because we create many promises from a single IDBRequest.\n  reverseTransformCache.set(promise, request);\n  return promise;\n}\nfunction cacheDonePromiseForTransaction(tx) {\n  // Early bail if we've already created a done promise for this transaction.\n  if (transactionDoneMap.has(tx)) return;\n  const done = new Promise((resolve, reject) => {\n    const unlisten = () => {\n      tx.removeEventListener('complete', complete);\n      tx.removeEventListener('error', error);\n      tx.removeEventListener('abort', error);\n    };\n    const complete = () => {\n      resolve();\n      unlisten();\n    };\n    const error = () => {\n      reject(tx.error || new DOMException('AbortError', 'AbortError'));\n      unlisten();\n    };\n    tx.addEventListener('complete', complete);\n    tx.addEventListener('error', error);\n    tx.addEventListener('abort', error);\n  });\n  // Cache it for later retrieval.\n  transactionDoneMap.set(tx, done);\n}\nlet idbProxyTraps = {\n  get(target, prop, receiver) {\n    if (target instanceof IDBTransaction) {\n      // Special handling for transaction.done.\n      if (prop === 'done') return transactionDoneMap.get(target);\n      // Polyfill for objectStoreNames because of Edge.\n      if (prop === 'objectStoreNames') {\n        return target.objectStoreNames || transactionStoreNamesMap.get(target);\n      }\n      // Make tx.store return the only store in the transaction, or undefined if there are many.\n      if (prop === 'store') {\n        return receiver.objectStoreNames[1] ? undefined : receiver.objectStore(receiver.objectStoreNames[0]);\n      }\n    }\n    // Else transform whatever we get back.\n    return wrap(target[prop]);\n  },\n  set(target, prop, value) {\n    target[prop] = value;\n    return true;\n  },\n  has(target, prop) {\n    if (target instanceof IDBTransaction && (prop === 'done' || prop === 'store')) {\n      return true;\n    }\n    return prop in target;\n  }\n};\nfunction replaceTraps(callback) {\n  idbProxyTraps = callback(idbProxyTraps);\n}\nfunction wrapFunction(func) {\n  // Due to expected object equality (which is enforced by the caching in `wrap`), we\n  // only create one new func per func.\n  // Edge doesn't support objectStoreNames (booo), so we polyfill it here.\n  if (func === IDBDatabase.prototype.transaction && !('objectStoreNames' in IDBTransaction.prototype)) {\n    return function (storeNames, ...args) {\n      const tx = func.call(unwrap(this), storeNames, ...args);\n      transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);\n      return wrap(tx);\n    };\n  }\n  // Cursor methods are special, as the behaviour is a little more different to standard IDB. In\n  // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the\n  // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense\n  // with real promises, so each advance methods returns a new promise for the cursor object, or\n  // undefined if the end of the cursor has been reached.\n  if (getCursorAdvanceMethods().includes(func)) {\n    return function (...args) {\n      // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use\n      // the original object.\n      func.apply(unwrap(this), args);\n      return wrap(cursorRequestMap.get(this));\n    };\n  }\n  return function (...args) {\n    // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use\n    // the original object.\n    return wrap(func.apply(unwrap(this), args));\n  };\n}\nfunction transformCachableValue(value) {\n  if (typeof value === 'function') return wrapFunction(value);\n  // This doesn't return, it just creates a 'done' promise for the transaction,\n  // which is later returned for transaction.done (see idbObjectHandler).\n  if (value instanceof IDBTransaction) cacheDonePromiseForTransaction(value);\n  if (instanceOfAny(value, getIdbProxyableTypes())) return new Proxy(value, idbProxyTraps);\n  // Return the same value back if we're not going to transform it.\n  return value;\n}\nfunction wrap(value) {\n  // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because\n  // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.\n  if (value instanceof IDBRequest) return promisifyRequest(value);\n  // If we've already transformed this value before, reuse the transformed value.\n  // This is faster, but it also provides object equality.\n  if (transformCache.has(value)) return transformCache.get(value);\n  const newValue = transformCachableValue(value);\n  // Not all types are transformed.\n  // These may be primitive types, so they can't be WeakMap keys.\n  if (newValue !== value) {\n    transformCache.set(value, newValue);\n    reverseTransformCache.set(newValue, value);\n  }\n  return newValue;\n}\nconst unwrap = value => reverseTransformCache.get(value);\nexport { reverseTransformCache as a, instanceOfAny as i, replaceTraps as r, unwrap as u, wrap as w };","import { w as wrap, r as replaceTraps } from './wrap-idb-value.js';\nexport { u as unwrap, w as wrap } from './wrap-idb-value.js';\n\n/**\n * Open a database.\n *\n * @param name Name of the database.\n * @param version Schema version.\n * @param callbacks Additional callbacks.\n */\nfunction openDB(name, version, {\n  blocked,\n  upgrade,\n  blocking,\n  terminated\n} = {}) {\n  const request = indexedDB.open(name, version);\n  const openPromise = wrap(request);\n  if (upgrade) {\n    request.addEventListener('upgradeneeded', event => {\n      upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);\n    });\n  }\n  if (blocked) {\n    request.addEventListener('blocked', event => blocked(\n    // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405\n    event.oldVersion, event.newVersion, event));\n  }\n  openPromise.then(db => {\n    if (terminated) db.addEventListener('close', () => terminated());\n    if (blocking) {\n      db.addEventListener('versionchange', event => blocking(event.oldVersion, event.newVersion, event));\n    }\n  }).catch(() => {});\n  return openPromise;\n}\n/**\n * Delete a database.\n *\n * @param name Name of the database.\n */\nfunction deleteDB(name, {\n  blocked\n} = {}) {\n  const request = indexedDB.deleteDatabase(name);\n  if (blocked) {\n    request.addEventListener('blocked', event => blocked(\n    // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405\n    event.oldVersion, event));\n  }\n  return wrap(request).then(() => undefined);\n}\nconst readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];\nconst writeMethods = ['put', 'add', 'delete', 'clear'];\nconst cachedMethods = new Map();\nfunction getMethod(target, prop) {\n  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === 'string')) {\n    return;\n  }\n  if (cachedMethods.get(prop)) return cachedMethods.get(prop);\n  const targetFuncName = prop.replace(/FromIndex$/, '');\n  const useIndex = prop !== targetFuncName;\n  const isWrite = writeMethods.includes(targetFuncName);\n  if (\n  // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.\n  !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) {\n    return;\n  }\n  const method = async function (storeName, ...args) {\n    // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(\n    const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');\n    let target = tx.store;\n    if (useIndex) target = target.index(args.shift());\n    // Must reject if op rejects.\n    // If it's a write operation, must reject if tx.done rejects.\n    // Must reject with op rejection first.\n    // Must resolve with op value.\n    // Must handle both promises (no unhandled rejections)\n    return (await Promise.all([target[targetFuncName](...args), isWrite && tx.done]))[0];\n  };\n  cachedMethods.set(prop, method);\n  return method;\n}\nreplaceTraps(oldTraps => ({\n  ...oldTraps,\n  get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),\n  has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)\n}));\nexport { deleteDB, openDB };"],"mappings":"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","names":["stringToByteArray$1","str","out","p","c","byteArrayToString","bytes","pos","c1","c2","c3","c4","u","base64","input","webSafe","byteToCharMap","output","i","byte1","haveByte2","byte2","haveByte3","byte3","outByte1","outByte2","outByte3","outByte4","charToByteMap","byte4","DecodeBase64StringError","base64Encode","utf8Bytes","base64urlEncodeWithoutPadding","base64Decode","deepExtend","target","source","dateValue","prop","isValidKey","key","getGlobal","getDefaultsFromGlobal","getDefaultsFromEnvVariable","defaultsJsonString","getDefaultsFromCookie","match","decoded","base64Decode","getDefaults","e","getDefaultEmulatorHost","productName","_a","_b","getDefaultEmulatorHostnameAndPort","host","separatorIndex","port","getDefaultAppConfig","getExperimentalSetting","name","Deferred","resolve","reject","callback","error","value","createMockUserToken","token","projectId","header","project","iat","sub","payload","base64urlEncodeWithoutPadding","getUA","isMobileCordova","isNode","forceEnvironment","isBrowser","isBrowserExtension","runtime","isReactNative","isIE","ua","getUA","isSafari","isNode","isIndexedDBAvailable","validateIndexedDBOpenable","resolve","reject","preExist","DB_CHECK_NAME","request","_a","error","ERROR_NAME","FirebaseError","_FirebaseError","code","message","customData","ErrorFactory","service","serviceName","errors","data","fullCode","template","replaceTemplate","fullMessage","PATTERN","_","key","value","contains","obj","key","isEmpty","obj","key","deepEqual","a","b","aKeys","bKeys","k","aProp","bProp","isObject","thing","querystring","querystringParams","params","key","value","arrayVal","querystringDecode","obj","token","extractQuerystring","url","queryStart","fragmentStart","createSubscribe","executor","onNoObservers","proxy","ObserverProxy","e","value","observer","error","nextOrObserver","complete","implementsAnyMethods","noop","unsub","i","fn","err","implementsAnyMethods","obj","methods","method","noop","MAX_VALUE_MILLIS","getModularInstance","service","Component","name","instanceFactory","type","mode","multipleInstances","props","callback","DEFAULT_ENTRY_NAME","Provider","container","identifier","normalizedIdentifier","deferred","Deferred","instance","options","_a","optional","e","component","isComponentEager","instanceIdentifier","instanceDeferred","__async","services","service","opts","normalizedDeferredIdentifier","existingCallbacks","existingInstance","callbacks","normalizeIdentifierForFactory","ComponentContainer","provider","instances","LogLevel","levelStringToEnum","defaultLogLevel","ConsoleMethod","defaultLogHandler","instance","logType","args","now","method","Logger","name","val","setLogLevel","level","inst","setUserLogHandler","logCallback","options","customLogLevel","message","arg","index_esm2017_exports","__export","FirebaseError","SDK_VERSION","DEFAULT_ENTRY_NAME","_addComponent","_addOrOverwriteComponent","_apps","_clearComponents","_components","_getProvider","_registerComponent","_removeServiceInstance","deleteApp","getApp","getApps","initializeApp","onLog","registerVersion","setLogLevel","instanceOfAny","object","constructors","c","idbProxyableTypes","cursorAdvanceMethods","getIdbProxyableTypes","getCursorAdvanceMethods","cursorRequestMap","transactionDoneMap","transactionStoreNamesMap","transformCache","reverseTransformCache","promisifyRequest","request","promise","resolve","reject","unlisten","success","error","wrap","value","cacheDonePromiseForTransaction","tx","done","complete","idbProxyTraps","target","prop","receiver","replaceTraps","callback","wrapFunction","func","storeNames","args","unwrap","transformCachableValue","newValue","openDB","name","version","blocked","upgrade","blocking","terminated","request","openPromise","wrap","event","db","readMethods","writeMethods","cachedMethods","getMethod","target","prop","targetFuncName","useIndex","isWrite","method","storeName","args","__async","tx","replaceTraps","oldTraps","__spreadProps","__spreadValues","receiver","PlatformLoggerServiceImpl","container","provider","isVersionServiceProvider","service","logString","component","name$o","version$1","logger","Logger","name$n","name$m","name$l","name$k","name$j","name$i","name$h","name$g","name$f","name$e","name$d","name$c","name$b","name$a","name$9","name$8","name$7","name$6","name$5","name$4","name$3","name$2","name$1","name","version","DEFAULT_ENTRY_NAME","PLATFORM_LOG_STRING","_apps","_components","_addComponent","app","e","_addOrOverwriteComponent","_registerComponent","componentName","_getProvider","heartbeatController","_removeServiceInstance","instanceIdentifier","_clearComponents","ERRORS","ERROR_FACTORY","ErrorFactory","FirebaseAppImpl","options","config","Component","val","SDK_VERSION","initializeApp","_options","rawConfig","getDefaultAppConfig","existingApp","deepEqual","ComponentContainer","newApp","getApp","getApps","deleteApp","__async","registerVersion","libraryKeyOrName","variant","_a","library","libraryMismatch","versionMismatch","warning","onLog","logCallback","setUserLogHandler","setLogLevel","logLevel","DB_NAME","DB_VERSION","STORE_NAME","dbPromise","getDbPromise","openDB","db","oldVersion","readHeartbeatsFromIndexedDB","computeKey","FirebaseError","idbGetError","writeHeartbeatsToIndexedDB","heartbeatObject","tx","MAX_HEADER_BYTES","STORED_HEARTBEAT_RETENTION_MAX_MILLIS","HeartbeatServiceImpl","HeartbeatStorageImpl","result","_b","agent","date","getUTCDateString","singleDateHeartbeat","hbTimestamp","heartbeatsToSend","unsentEntries","extractHeartbeatsForHeader","headerString","base64urlEncodeWithoutPadding","heartbeatsCache","maxSize","heartbeatEntry","hb","countBytes","isIndexedDBAvailable","validateIndexedDBOpenable","idbHeartbeatObject","heartbeatsObject","existingHeartbeatsObject","registerCoreComponents"],"x_google_ignoreList":[0,1,2,3,4,5]}