{"version":3,"file":"firebase-app-compat.js","sources":["../util/src/crypt.ts","../util/src/deepCopy.ts","../util/src/deferred.ts","../util/src/errors.ts","../util/src/obj.ts","../util/src/subscribe.ts","../util/src/indexeddb.ts","../component/src/component.ts","../component/src/constants.ts","../component/src/provider.ts","../component/src/component_container.ts","../logger/src/logger.ts","../app/src/platformLoggerService.ts","../app/src/logger.ts","../app/src/registerCoreComponents.ts","../app/src/constants.ts","../app/src/internal.ts","../app/src/errors.ts","../app/src/firebaseApp.ts","../app/src/api.ts","../app/src/indexeddb.ts","../app/src/heartbeatService.ts","../util/src/environment.ts","../app/src/index.ts","../app-compat/src/firebaseApp.ts","../app-compat/src/errors.ts","../app-compat/src/firebaseNamespaceCore.ts","../app-compat/src/firebaseNamespace.ts","../app-compat/src/logger.ts","../app-compat/src/index.ts","../app-compat/src/registerCoreComponents.ts","compat/app/index.cdn.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst stringToByteArray = function (str: string): number[] {\n  // TODO(user): Use native implementations if/when available\n  const out: number[] = [];\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 (\n      (c & 0xfc00) === 0xd800 &&\n      i + 1 < str.length &&\n      (str.charCodeAt(i + 1) & 0xfc00) === 0xdc00\n    ) {\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\n/**\n * Turns an array of numbers into the string given by the concatenation of the\n * characters to which the numbers correspond.\n * @param bytes Array of numbers representing characters.\n * @return Stringification of the array.\n */\nconst byteArrayToString = function (bytes: number[]): string {\n  // TODO(user): Use native implementations if/when available\n  const out: string[] = [];\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 =\n        (((c1 & 7) << 18) | ((c2 & 63) << 12) | ((c3 & 63) << 6) | (c4 & 63)) -\n        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(\n        ((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63)\n      );\n    }\n  }\n  return out.join('');\n};\n\ninterface Base64 {\n  byteToCharMap_: { [key: number]: string } | null;\n  charToByteMap_: { [key: string]: number } | null;\n  byteToCharMapWebSafe_: { [key: number]: string } | null;\n  charToByteMapWebSafe_: { [key: string]: number } | null;\n  ENCODED_VALS_BASE: string;\n  readonly ENCODED_VALS: string;\n  readonly ENCODED_VALS_WEBSAFE: string;\n  HAS_NATIVE_SUPPORT: boolean;\n  encodeByteArray(input: number[] | Uint8Array, webSafe?: boolean): string;\n  encodeString(input: string, webSafe?: boolean): string;\n  decodeString(input: string, webSafe: boolean): string;\n  decodeStringToByteArray(input: string, webSafe: boolean): number[];\n  init_(): void;\n}\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_()\nexport const base64: Base64 = {\n  /**\n   * Maps bytes to characters.\n   */\n  byteToCharMap_: null,\n\n  /**\n   * Maps characters to bytes.\n   */\n  charToByteMap_: null,\n\n  /**\n   * Maps bytes to websafe characters.\n   * @private\n   */\n  byteToCharMapWebSafe_: null,\n\n  /**\n   * Maps websafe characters to bytes.\n   * @private\n   */\n  charToByteMapWebSafe_: null,\n\n  /**\n   * Our default alphabet, shared between\n   * ENCODED_VALS and ENCODED_VALS_WEBSAFE\n   */\n  ENCODED_VALS_BASE:\n    'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + 'abcdefghijklmnopqrstuvwxyz' + '0123456789',\n\n  /**\n   * Our default alphabet. Value 64 (=) is special; it means \"nothing.\"\n   */\n  get ENCODED_VALS() {\n    return this.ENCODED_VALS_BASE + '+/=';\n  },\n\n  /**\n   * Our websafe alphabet.\n   */\n  get ENCODED_VALS_WEBSAFE() {\n    return this.ENCODED_VALS_BASE + '-_.';\n  },\n\n  /**\n   * Whether this browser supports the atob and btoa functions. This extension\n   * started at Mozilla but is now implemented by many browsers. We use the\n   * ASSUME_* variables to avoid pulling in the full useragent detection library\n   * but still allowing the standard per-browser compilations.\n   *\n   */\n  HAS_NATIVE_SUPPORT: typeof atob === 'function',\n\n  /**\n   * Base64-encode an array of bytes.\n   *\n   * @param input An array of bytes (numbers with\n   *     value in [0, 255]) to encode.\n   * @param webSafe Boolean indicating we should use the\n   *     alternative alphabet.\n   * @return The base64 encoded string.\n   */\n  encodeByteArray(input: number[] | Uint8Array, webSafe?: boolean): string {\n    if (!Array.isArray(input)) {\n      throw Error('encodeByteArray takes an array as a parameter');\n    }\n\n    this.init_();\n\n    const byteToCharMap = webSafe\n      ? this.byteToCharMapWebSafe_!\n      : this.byteToCharMap_!;\n\n    const output = [];\n\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\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\n      if (!haveByte3) {\n        outByte4 = 64;\n\n        if (!haveByte2) {\n          outByte3 = 64;\n        }\n      }\n\n      output.push(\n        byteToCharMap[outByte1],\n        byteToCharMap[outByte2],\n        byteToCharMap[outByte3],\n        byteToCharMap[outByte4]\n      );\n    }\n\n    return output.join('');\n  },\n\n  /**\n   * Base64-encode a string.\n   *\n   * @param input A string to encode.\n   * @param webSafe If true, we should use the\n   *     alternative alphabet.\n   * @return The base64 encoded string.\n   */\n  encodeString(input: string, webSafe?: boolean): string {\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(input), webSafe);\n  },\n\n  /**\n   * Base64-decode a string.\n   *\n   * @param input to decode.\n   * @param webSafe True if we should use the\n   *     alternative alphabet.\n   * @return string representing the decoded value.\n   */\n  decodeString(input: string, webSafe: boolean): string {\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\n  /**\n   * Base64-decode a string.\n   *\n   * In base-64 decoding, groups of four characters are converted into three\n   * bytes.  If the encoder did not apply padding, the input length may not\n   * be a multiple of 4.\n   *\n   * In this case, the last group will have fewer than 4 characters, and\n   * padding will be inferred.  If the group has one or two characters, it decodes\n   * to one byte.  If the group has three characters, it decodes to two bytes.\n   *\n   * @param input Input to decode.\n   * @param webSafe True if we should use the web-safe alphabet.\n   * @return bytes representing the decoded value.\n   */\n  decodeStringToByteArray(input: string, webSafe: boolean): number[] {\n    this.init_();\n\n    const charToByteMap = webSafe\n      ? this.charToByteMapWebSafe_!\n      : this.charToByteMap_!;\n\n    const output: number[] = [];\n\n    for (let i = 0; i < input.length; ) {\n      const byte1 = charToByteMap[input.charAt(i++)];\n\n      const haveByte2 = i < input.length;\n      const byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;\n      ++i;\n\n      const haveByte3 = i < input.length;\n      const byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;\n      ++i;\n\n      const haveByte4 = i < input.length;\n      const byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;\n      ++i;\n\n      if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {\n        throw Error();\n      }\n\n      const outByte1 = (byte1 << 2) | (byte2 >> 4);\n      output.push(outByte1);\n\n      if (byte3 !== 64) {\n        const outByte2 = ((byte2 << 4) & 0xf0) | (byte3 >> 2);\n        output.push(outByte2);\n\n        if (byte4 !== 64) {\n          const outByte3 = ((byte3 << 6) & 0xc0) | byte4;\n          output.push(outByte3);\n        }\n      }\n    }\n\n    return output;\n  },\n\n  /**\n   * Lazy static initialization function. Called before\n   * accessing any of the static map variables.\n   * @private\n   */\n  init_() {\n    if (!this.byteToCharMap_) {\n      this.byteToCharMap_ = {};\n      this.charToByteMap_ = {};\n      this.byteToCharMapWebSafe_ = {};\n      this.charToByteMapWebSafe_ = {};\n\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\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\n/**\n * URL-safe base64 encoding\n */\nexport const base64Encode = function (str: string): string {\n  const utf8Bytes = stringToByteArray(str);\n  return base64.encodeByteArray(utf8Bytes, true);\n};\n\n/**\n * URL-safe base64 encoding (without \".\" padding in the end).\n * e.g. Used in JSON Web Token (JWT) parts.\n */\nexport const base64urlEncodeWithoutPadding = function (str: string): string {\n  // Use base64url encoding and remove padding in the end (dot characters).\n  return base64Encode(str).replace(/\\./g, '');\n};\n\n/**\n * URL-safe base64 decoding\n *\n * NOTE: DO NOT use the global atob() function - it does NOT support the\n * base64Url variant encoding.\n *\n * @param str To be decoded\n * @return Decoded result, if possible\n */\nexport const base64Decode = function (str: string): string | null {\n  try {\n    return base64.decodeString(str, true);\n  } catch (e) {\n    console.error('base64Decode failed: ', e);\n  }\n  return null;\n};\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Do a deep-copy of basic JavaScript Objects or Arrays.\n */\nexport function deepCopy<T>(value: T): T {\n  return deepExtend(undefined, value) as T;\n}\n\n/**\n * Copy properties from source to target (recursively allows extension\n * of Objects and Arrays).  Scalar values in the target are over-written.\n * If target is undefined, an object of the appropriate type will be created\n * (and returned).\n *\n * We recursively copy all child properties of plain Objects in the source- so\n * that namespace- like dictionaries are merged.\n *\n * Note that the target can be a function, in which case the properties in\n * the source Object are copied onto it as static properties of the Function.\n *\n * Note: we don't merge __proto__ to prevent prototype pollution\n */\nexport function deepExtend(target: unknown, source: unknown): unknown {\n  if (!(source instanceof Object)) {\n    return source;\n  }\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 as Date;\n      return new Date(dateValue.getTime());\n\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\n    default:\n      // Not a plain Object - treat it as a scalar.\n      return source;\n  }\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 as Record<string, unknown>)[prop] = deepExtend(\n      (target as Record<string, unknown>)[prop],\n      (source as Record<string, unknown>)[prop]\n    );\n  }\n\n  return target;\n}\n\nfunction isValidKey(key: string): boolean {\n  return key !== '__proto__';\n}\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport class Deferred<R> {\n  promise: Promise<R>;\n  reject: (value?: unknown) => void = () => {};\n  resolve: (value?: unknown) => void = () => {};\n  constructor() {\n    this.promise = new Promise((resolve, reject) => {\n      this.resolve = resolve as (value?: unknown) => void;\n      this.reject = reject as (value?: unknown) => void;\n    });\n  }\n\n  /**\n   * Our API internals are not promiseified and cannot because our callback APIs have subtle expectations around\n   * invoking promises inline, which Promises are forbidden to do. This method accepts an optional node-style callback\n   * and returns a node-style callback which will resolve or reject the Deferred's promise.\n   */\n  wrapCallback(\n    callback?: (error?: unknown, value?: unknown) => void\n  ): (error: unknown, value?: unknown) => void {\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\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 * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * @fileoverview Standardized Firebase Error.\n *\n * Usage:\n *\n *   // Typescript string literals for type-safe codes\n *   type Err =\n *     'unknown' |\n *     'object-not-found'\n *     ;\n *\n *   // Closure enum for type-safe error codes\n *   // at-enum {string}\n *   var Err = {\n *     UNKNOWN: 'unknown',\n *     OBJECT_NOT_FOUND: 'object-not-found',\n *   }\n *\n *   let errors: Map<Err, string> = {\n *     'generic-error': \"Unknown error\",\n *     'file-not-found': \"Could not find file: {$file}\",\n *   };\n *\n *   // Type-safe function - must pass a valid error code as param.\n *   let error = new ErrorFactory<Err>('service', 'Service', errors);\n *\n *   ...\n *   throw error.create(Err.GENERIC);\n *   ...\n *   throw error.create(Err.FILE_NOT_FOUND, {'file': fileName});\n *   ...\n *   // Service: Could not file file: foo.txt (service/file-not-found).\n *\n *   catch (e) {\n *     assert(e.message === \"Could not find file: foo.txt.\");\n *     if (e.code === 'service/file-not-found') {\n *       console.log(\"Could not read file: \" + e['file']);\n *     }\n *   }\n */\n\nexport type ErrorMap<ErrorCode extends string> = {\n  readonly [K in ErrorCode]: string;\n};\n\nconst ERROR_NAME = 'FirebaseError';\n\nexport interface StringLike {\n  toString(): string;\n}\n\nexport interface ErrorData {\n  [key: string]: unknown;\n}\n\n// Based on code from:\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Custom_Error_Types\nexport class FirebaseError extends Error {\n  /** The custom name for all FirebaseErrors. */\n  readonly name: string = ERROR_NAME;\n\n  constructor(\n    /** The error code for this error. */\n    readonly code: string,\n    message: string,\n    /** Custom data for this error. */\n    public customData?: Record<string, unknown>\n  ) {\n    super(message);\n\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\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}\n\nexport class ErrorFactory<\n  ErrorCode extends string,\n  ErrorParams extends { readonly [K in ErrorCode]?: ErrorData } = {}\n> {\n  constructor(\n    private readonly service: string,\n    private readonly serviceName: string,\n    private readonly errors: ErrorMap<ErrorCode>\n  ) {}\n\n  create<K extends ErrorCode>(\n    code: K,\n    ...data: K extends keyof ErrorParams ? [ErrorParams[K]] : []\n  ): FirebaseError {\n    const customData = (data[0] as ErrorData) || {};\n    const fullCode = `${this.service}/${code}`;\n    const template = this.errors[code];\n\n    const message = template ? replaceTemplate(template, customData) : 'Error';\n    // Service Name: Error message (service/code).\n    const fullMessage = `${this.serviceName}: ${message} (${fullCode}).`;\n\n    const error = new FirebaseError(fullCode, fullMessage, customData);\n\n    return error;\n  }\n}\n\nfunction replaceTemplate(template: string, data: ErrorData): string {\n  return template.replace(PATTERN, (_, key) => {\n    const value = data[key];\n    return value != null ? String(value) : `<${key}?>`;\n  });\n}\n\nconst PATTERN = /\\{\\$([^}]+)}/g;\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport function contains<T extends object>(obj: T, key: string): boolean {\n  return Object.prototype.hasOwnProperty.call(obj, key);\n}\n\nexport function safeGet<T extends object, K extends keyof T>(\n  obj: T,\n  key: K\n): T[K] | undefined {\n  if (Object.prototype.hasOwnProperty.call(obj, key)) {\n    return obj[key];\n  } else {\n    return undefined;\n  }\n}\n\nexport function isEmpty(obj: object): obj is {} {\n  for (const key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function map<K extends string, V, U>(\n  obj: { [key in K]: V },\n  fn: (value: V, key: K, obj: { [key in K]: V }) => U,\n  contextObj?: unknown\n): { [key in K]: U } {\n  const res: Partial<{ [key in K]: U }> = {};\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 as { [key in K]: U };\n}\n\n/**\n * Deep equal two objects. Support Arrays and Objects.\n */\nexport function deepEqual(a: object, b: object): boolean {\n  if (a === b) {\n    return true;\n  }\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\n    const aProp = (a as Record<string, unknown>)[k];\n    const bProp = (b as Record<string, unknown>)[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\n  for (const k of bKeys) {\n    if (!aKeys.includes(k)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction isObject(thing: unknown): thing is object {\n  return thing !== null && typeof thing === 'object';\n}\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nexport type NextFn<T> = (value: T) => void;\nexport type ErrorFn = (error: Error) => void;\nexport type CompleteFn = () => void;\n\nexport interface Observer<T> {\n  // Called once for each value in a stream of values.\n  next: NextFn<T>;\n\n  // A stream terminates by a single call to EITHER error() or complete().\n  error: ErrorFn;\n\n  // No events will be sent to next() once complete() is called.\n  complete: CompleteFn;\n}\n\nexport type PartialObserver<T> = Partial<Observer<T>>;\n\n// TODO: Support also Unsubscribe.unsubscribe?\nexport type Unsubscribe = () => void;\n\n/**\n * The Subscribe interface has two forms - passing the inline function\n * callbacks, or a object interface with callback properties.\n */\nexport interface Subscribe<T> {\n  (next?: NextFn<T>, error?: ErrorFn, complete?: CompleteFn): Unsubscribe;\n  (observer: PartialObserver<T>): Unsubscribe;\n}\n\nexport interface Observable<T> {\n  // Subscribe method\n  subscribe: Subscribe<T>;\n}\n\nexport type Executor<T> = (observer: Observer<T>) => void;\n\n/**\n * Helper to make a Subscribe function (just like Promise helps make a\n * Thenable).\n *\n * @param executor Function which can make calls to a single Observer\n *     as a proxy.\n * @param onNoObservers Callback when count of Observers goes to zero.\n */\nexport function createSubscribe<T>(\n  executor: Executor<T>,\n  onNoObservers?: Executor<T>\n): Subscribe<T> {\n  const proxy = new ObserverProxy<T>(executor, onNoObservers);\n  return proxy.subscribe.bind(proxy);\n}\n\n/**\n * Implement fan-out for any number of Observers attached via a subscribe\n * function.\n */\nclass ObserverProxy<T> implements Observer<T> {\n  private observers: Array<Observer<T>> | undefined = [];\n  private unsubscribes: Unsubscribe[] = [];\n  private onNoObservers: Executor<T> | undefined;\n  private observerCount = 0;\n  // Micro-task scheduling by calling task.then().\n  private task = Promise.resolve();\n  private finalized = false;\n  private finalError?: Error;\n\n  /**\n   * @param executor Function which can make calls to a single Observer\n   *     as a proxy.\n   * @param onNoObservers Callback when count of Observers goes to zero.\n   */\n  constructor(executor: Executor<T>, onNoObservers?: Executor<T>) {\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\n      .then(() => {\n        executor(this);\n      })\n      .catch(e => {\n        this.error(e);\n      });\n  }\n\n  next(value: T): void {\n    this.forEachObserver((observer: Observer<T>) => {\n      observer.next(value);\n    });\n  }\n\n  error(error: Error): void {\n    this.forEachObserver((observer: Observer<T>) => {\n      observer.error(error);\n    });\n    this.close(error);\n  }\n\n  complete(): void {\n    this.forEachObserver((observer: Observer<T>) => {\n      observer.complete();\n    });\n    this.close();\n  }\n\n  /**\n   * Subscribe function that can be used to add an Observer to the fan-out list.\n   *\n   * - We require that no event is sent to a subscriber sychronously to their\n   *   call to subscribe().\n   */\n  subscribe(\n    nextOrObserver?: NextFn<T> | PartialObserver<T>,\n    error?: ErrorFn,\n    complete?: CompleteFn\n  ): Unsubscribe {\n    let observer: Observer<T>;\n\n    if (\n      nextOrObserver === undefined &&\n      error === undefined &&\n      complete === undefined\n    ) {\n      throw new Error('Missing Observer.');\n    }\n\n    // Assemble an Observer object when passed as callback functions.\n    if (\n      implementsAnyMethods(nextOrObserver as { [key: string]: unknown }, [\n        'next',\n        'error',\n        'complete'\n      ])\n    ) {\n      observer = nextOrObserver as Observer<T>;\n    } else {\n      observer = {\n        next: nextOrObserver as NextFn<T>,\n        error,\n        complete\n      } as Observer<T>;\n    }\n\n    if (observer.next === undefined) {\n      observer.next = noop as NextFn<T>;\n    }\n    if (observer.error === undefined) {\n      observer.error = noop as ErrorFn;\n    }\n    if (observer.complete === undefined) {\n      observer.complete = noop as CompleteFn;\n    }\n\n    const unsub = this.unsubscribeOne.bind(this, this.observers!.length);\n\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\n    this.observers!.push(observer as Observer<T>);\n\n    return unsub;\n  }\n\n  // Unsubscribe is synchronous - we guarantee that no events are sent to\n  // any unsubscribed Observer.\n  private unsubscribeOne(i: number): void {\n    if (this.observers === undefined || this.observers[i] === undefined) {\n      return;\n    }\n\n    delete this.observers[i];\n\n    this.observerCount -= 1;\n    if (this.observerCount === 0 && this.onNoObservers !== undefined) {\n      this.onNoObservers(this);\n    }\n  }\n\n  private forEachObserver(fn: (observer: Observer<T>) => void): void {\n    if (this.finalized) {\n      // Already closed by previous event....just eat the additional values.\n      return;\n    }\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\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  private sendOne(i: number, fn: (observer: Observer<T>) => void): void {\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\n  private close(err?: Error): void {\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\n/** Turn synchronous function into one called asynchronously. */\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport function async(fn: Function, onError?: ErrorFn): Function {\n  return (...args: unknown[]) => {\n    Promise.resolve(true)\n      .then(() => {\n        fn(...args);\n      })\n      .catch((error: Error) => {\n        if (onError) {\n          onError(error);\n        }\n      });\n  };\n}\n\n/**\n * Return true if the object passed in implements any of the named methods.\n */\nfunction implementsAnyMethods(\n  obj: { [key: string]: unknown },\n  methods: string[]\n): boolean {\n  if (typeof obj !== 'object' || obj === null) {\n    return false;\n  }\n\n  for (const method of methods) {\n    if (method in obj && typeof obj[method] === 'function') {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction noop(): void {\n  // do nothing\n}\n","/**\n * @license\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @internal\n */\nfunction promisifyRequest(\n  request: IDBRequest,\n  errorMessage: string\n): Promise<unknown> {\n  return new Promise((resolve, reject) => {\n    request.onsuccess = event => {\n      resolve((event.target as IDBRequest).result);\n    };\n    request.onerror = event => {\n      reject(`${errorMessage}: ${(event.target as IDBRequest).error?.message}`);\n    };\n  });\n}\n\n/**\n * @internal\n */\nexport class DBWrapper {\n  objectStoreNames: DOMStringList;\n  constructor(private _db: IDBDatabase) {\n    this.objectStoreNames = this._db.objectStoreNames;\n  }\n  transaction(\n    storeNames: string[] | string,\n    mode?: IDBTransactionMode\n  ): TransactionWrapper {\n    return new TransactionWrapper(\n      this._db.transaction.call(this._db, storeNames, mode)\n    );\n  }\n  createObjectStore(\n    storeName: string,\n    options?: IDBObjectStoreParameters\n  ): ObjectStoreWrapper {\n    return new ObjectStoreWrapper(\n      this._db.createObjectStore(storeName, options)\n    );\n  }\n  close(): void {\n    this._db.close();\n  }\n}\n\n/**\n * @internal\n */\nclass TransactionWrapper {\n  complete: Promise<void>;\n  constructor(private _transaction: IDBTransaction) {\n    this.complete = new Promise((resolve, reject) => {\n      this._transaction.oncomplete = function () {\n        resolve();\n      };\n      this._transaction.onerror = () => {\n        reject(this._transaction.error);\n      };\n      this._transaction.onabort = () => {\n        reject(this._transaction.error);\n      };\n    });\n  }\n  objectStore(storeName: string): ObjectStoreWrapper {\n    return new ObjectStoreWrapper(this._transaction.objectStore(storeName));\n  }\n}\n\n/**\n * @internal\n */\nclass ObjectStoreWrapper {\n  constructor(private _store: IDBObjectStore) {}\n  index(name: string): IndexWrapper {\n    return new IndexWrapper(this._store.index(name));\n  }\n  createIndex(\n    name: string,\n    keypath: string,\n    options: IDBIndexParameters\n  ): IndexWrapper {\n    return new IndexWrapper(this._store.createIndex(name, keypath, options));\n  }\n  get(key: string): Promise<unknown> {\n    const request = this._store.get(key);\n    return promisifyRequest(request, 'Error reading from IndexedDB');\n  }\n  put(value: unknown, key?: string): Promise<unknown> {\n    const request = this._store.put(value, key);\n    return promisifyRequest(request, 'Error writing to IndexedDB');\n  }\n  delete(key: string): Promise<unknown> {\n    const request = this._store.delete(key);\n    return promisifyRequest(request, 'Error deleting from IndexedDB');\n  }\n  clear(): Promise<unknown> {\n    const request = this._store.clear();\n    return promisifyRequest(request, 'Error clearing IndexedDB object store');\n  }\n}\n\n/**\n * @internal\n */\nclass IndexWrapper {\n  constructor(private _index: IDBIndex) {}\n  get(key: string): Promise<unknown> {\n    const request = this._index.get(key);\n    return promisifyRequest(request, 'Error reading from IndexedDB');\n  }\n}\n\n/**\n * @internal\n */\nexport function openDB(\n  dbName: string,\n  dbVersion: number,\n  upgradeCallback: (\n    db: DBWrapper,\n    oldVersion: number,\n    newVersion: number | null,\n    transaction: TransactionWrapper\n  ) => void\n): Promise<DBWrapper> {\n  return new Promise((resolve, reject) => {\n    try {\n      const request = indexedDB.open(dbName, dbVersion);\n\n      request.onsuccess = event => {\n        resolve(new DBWrapper((event.target as IDBOpenDBRequest).result));\n      };\n\n      request.onerror = event => {\n        reject(\n          `Error opening indexedDB: ${\n            (event.target as IDBRequest).error?.message\n          }`\n        );\n      };\n\n      request.onupgradeneeded = event => {\n        upgradeCallback(\n          new DBWrapper(request.result),\n          event.oldVersion,\n          event.newVersion,\n          new TransactionWrapper(request.transaction!)\n        );\n      };\n    } catch (e) {\n      reject(`Error opening indexedDB: ${e.message}`);\n    }\n  });\n}\n\n/**\n * @internal\n */\nexport async function deleteDB(dbName: string): Promise<void> {\n  return new Promise((resolve, reject) => {\n    try {\n      const request = indexedDB.deleteDatabase(dbName);\n      request.onsuccess = () => {\n        resolve();\n      };\n      request.onerror = event => {\n        reject(\n          `Error deleting indexedDB database \"${dbName}\": ${\n            (event.target as IDBRequest).error?.message\n          }`\n        );\n      };\n    } catch (e) {\n      reject(`Error deleting indexedDB database \"${dbName}\": ${e.message}`);\n    }\n  });\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport {\n  InstantiationMode,\n  InstanceFactory,\n  ComponentType,\n  Dictionary,\n  Name,\n  onInstanceCreatedCallback\n} from './types';\n\n/**\n * Component for service name T, e.g. `auth`, `auth-internal`\n */\nexport class Component<T extends Name = Name> {\n  multipleInstances = false;\n  /**\n   * Properties to be added to the service namespace\n   */\n  serviceProps: Dictionary = {};\n\n  instantiationMode = InstantiationMode.LAZY;\n\n  onInstanceCreated: onInstanceCreatedCallback<T> | null = null;\n\n  /**\n   *\n   * @param name The public service name, e.g. app, auth, firestore, database\n   * @param instanceFactory Service factory responsible for creating the public interface\n   * @param type whether the service provided by the component is public or private\n   */\n  constructor(\n    readonly name: T,\n    readonly instanceFactory: InstanceFactory<T>,\n    readonly type: ComponentType\n  ) {}\n\n  setInstantiationMode(mode: InstantiationMode): this {\n    this.instantiationMode = mode;\n    return this;\n  }\n\n  setMultipleInstances(multipleInstances: boolean): this {\n    this.multipleInstances = multipleInstances;\n    return this;\n  }\n\n  setServiceProps(props: Dictionary): this {\n    this.serviceProps = props;\n    return this;\n  }\n\n  setInstanceCreatedCallback(callback: onInstanceCreatedCallback<T>): this {\n    this.onInstanceCreated = callback;\n    return this;\n  }\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport const DEFAULT_ENTRY_NAME = '[DEFAULT]';\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Deferred } from '@firebase/util';\nimport { ComponentContainer } from './component_container';\nimport { DEFAULT_ENTRY_NAME } from './constants';\nimport {\n  InitializeOptions,\n  InstantiationMode,\n  Name,\n  NameServiceMapping,\n  OnInitCallBack\n} from './types';\nimport { Component } from './component';\n\n/**\n * Provider for instance for service name T, e.g. 'auth', 'auth-internal'\n * NameServiceMapping[T] is an alias for the type of the instance\n */\nexport class Provider<T extends Name> {\n  private component: Component<T> | null = null;\n  private readonly instances: Map<string, NameServiceMapping[T]> = new Map();\n  private readonly instancesDeferred: Map<\n    string,\n    Deferred<NameServiceMapping[T]>\n  > = new Map();\n  private readonly instancesOptions: Map<string, Record<string, unknown>> =\n    new Map();\n  private onInitCallbacks: Map<string, Set<OnInitCallBack<T>>> = new Map();\n\n  constructor(\n    private readonly name: T,\n    private readonly container: ComponentContainer\n  ) {}\n\n  /**\n   * @param identifier A provider can provide mulitple instances of a service\n   * if this.component.multipleInstances is true.\n   */\n  get(identifier?: string): Promise<NameServiceMapping[T]> {\n    // if multipleInstances is not supported, use the default name\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);\n\n    if (!this.instancesDeferred.has(normalizedIdentifier)) {\n      const deferred = new Deferred<NameServiceMapping[T]>();\n      this.instancesDeferred.set(normalizedIdentifier, deferred);\n\n      if (\n        this.isInitialized(normalizedIdentifier) ||\n        this.shouldAutoInitialize()\n      ) {\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\n    return this.instancesDeferred.get(normalizedIdentifier)!.promise;\n  }\n\n  /**\n   *\n   * @param options.identifier A provider can provide mulitple instances of a service\n   * if this.component.multipleInstances is true.\n   * @param options.optional If optional is false or not provided, the method throws an error when\n   * the service is not immediately available.\n   * If optional is true, the method returns null if the service is not immediately available.\n   */\n  getImmediate(options: {\n    identifier?: string;\n    optional: true;\n  }): NameServiceMapping[T] | null;\n  getImmediate(options?: {\n    identifier?: string;\n    optional?: false;\n  }): NameServiceMapping[T];\n  getImmediate(options?: {\n    identifier?: string;\n    optional?: boolean;\n  }): NameServiceMapping[T] | null {\n    // if multipleInstances is not supported, use the default name\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(\n      options?.identifier\n    );\n    const optional = options?.optional ?? false;\n\n    if (\n      this.isInitialized(normalizedIdentifier) ||\n      this.shouldAutoInitialize()\n    ) {\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\n  getComponent(): Component<T> | null {\n    return this.component;\n  }\n\n  setComponent(component: Component<T>): void {\n    if (component.name !== this.name) {\n      throw Error(\n        `Mismatching Component ${component.name} for Provider ${this.name}.`\n      );\n    }\n\n    if (this.component) {\n      throw Error(`Component for ${this.name} has already been provided`);\n    }\n\n    this.component = component;\n\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\n    // if the service is eager, initialize the default instance\n    if (isComponentEager(component)) {\n      try {\n        this.getOrInitializeService({ instanceIdentifier: DEFAULT_ENTRY_NAME });\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\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 [\n      instanceIdentifier,\n      instanceDeferred\n    ] of this.instancesDeferred.entries()) {\n      const normalizedIdentifier =\n        this.normalizeInstanceIdentifier(instanceIdentifier);\n\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\n  clearInstance(identifier: string = DEFAULT_ENTRY_NAME): void {\n    this.instancesDeferred.delete(identifier);\n    this.instancesOptions.delete(identifier);\n    this.instances.delete(identifier);\n  }\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(): Promise<void> {\n    const services = Array.from(this.instances.values());\n\n    await Promise.all([\n      ...services\n        .filter(service => 'INTERNAL' in service) // legacy services\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        .map(service => (service as any).INTERNAL!.delete()),\n      ...services\n        .filter(service => '_delete' in service) // modularized services\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        .map(service => (service as any)._delete())\n    ]);\n  }\n\n  isComponentSet(): boolean {\n    return this.component != null;\n  }\n\n  isInitialized(identifier: string = DEFAULT_ENTRY_NAME): boolean {\n    return this.instances.has(identifier);\n  }\n\n  getOptions(identifier: string = DEFAULT_ENTRY_NAME): Record<string, unknown> {\n    return this.instancesOptions.get(identifier) || {};\n  }\n\n  initialize(opts: InitializeOptions = {}): NameServiceMapping[T] {\n    const { options = {} } = opts;\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(\n      opts.instanceIdentifier\n    );\n    if (this.isInitialized(normalizedIdentifier)) {\n      throw Error(\n        `${this.name}(${normalizedIdentifier}) has already been initialized`\n      );\n    }\n\n    if (!this.isComponentSet()) {\n      throw Error(`Component ${this.name} has not been registered yet`);\n    }\n\n    const instance = this.getOrInitializeService({\n      instanceIdentifier: normalizedIdentifier,\n      options\n    })!;\n\n    // resolve any pending promise waiting for the service instance\n    for (const [\n      instanceIdentifier,\n      instanceDeferred\n    ] of this.instancesDeferred.entries()) {\n      const normalizedDeferredIdentifier =\n        this.normalizeInstanceIdentifier(instanceIdentifier);\n      if (normalizedIdentifier === normalizedDeferredIdentifier) {\n        instanceDeferred.resolve(instance);\n      }\n    }\n\n    return instance;\n  }\n\n  /**\n   *\n   * @param callback - a function that will be invoked  after the provider has been initialized by calling provider.initialize().\n   * The function is invoked SYNCHRONOUSLY, so it should not execute any longrunning tasks in order to not block the program.\n   *\n   * @param identifier An optional instance identifier\n   * @returns a function to unregister the callback\n   */\n  onInit(callback: OnInitCallBack<T>, identifier?: string): () => void {\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);\n    const existingCallbacks =\n      this.onInitCallbacks.get(normalizedIdentifier) ??\n      new Set<OnInitCallBack<T>>();\n    existingCallbacks.add(callback);\n    this.onInitCallbacks.set(normalizedIdentifier, existingCallbacks);\n\n    const existingInstance = this.instances.get(normalizedIdentifier);\n    if (existingInstance) {\n      callback(existingInstance, normalizedIdentifier);\n    }\n\n    return () => {\n      existingCallbacks.delete(callback);\n    };\n  }\n\n  /**\n   * Invoke onInit callbacks synchronously\n   * @param instance the service instance`\n   */\n  private invokeOnInitCallbacks(\n    instance: NameServiceMapping[T],\n    identifier: string\n  ): void {\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 {\n        // ignore errors in the onInit callback\n      }\n    }\n  }\n\n  private getOrInitializeService({\n    instanceIdentifier,\n    options = {}\n  }: {\n    instanceIdentifier: string;\n    options?: Record<string, unknown>;\n  }): NameServiceMapping[T] | null {\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\n      /**\n       * Invoke onInit listeners.\n       * Note this.component.onInstanceCreated is different, which is used by the component creator,\n       * while onInit listeners are registered by consumers of the provider.\n       */\n      this.invokeOnInitCallbacks(instance, instanceIdentifier);\n\n      /**\n       * Order is important\n       * onInstanceCreated() should be called after this.instances.set(instanceIdentifier, instance); which\n       * makes `isInitialized()` return true.\n       */\n      if (this.component.onInstanceCreated) {\n        try {\n          this.component.onInstanceCreated(\n            this.container,\n            instanceIdentifier,\n            instance\n          );\n        } catch {\n          // ignore errors in the onInstanceCreatedCallback\n        }\n      }\n    }\n\n    return instance || null;\n  }\n\n  private normalizeInstanceIdentifier(\n    identifier: string = DEFAULT_ENTRY_NAME\n  ): string {\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\n  private shouldAutoInitialize(): boolean {\n    return (\n      !!this.component &&\n      this.component.instantiationMode !== InstantiationMode.EXPLICIT\n    );\n  }\n}\n\n// undefined should be passed to the service factory for the default instance\nfunction normalizeIdentifierForFactory(identifier: string): string | undefined {\n  return identifier === DEFAULT_ENTRY_NAME ? undefined : identifier;\n}\n\nfunction isComponentEager<T extends Name>(component: Component<T>): boolean {\n  return component.instantiationMode === InstantiationMode.EAGER;\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Provider } from './provider';\nimport { Component } from './component';\nimport { Name } from './types';\n\n/**\n * ComponentContainer that provides Providers for service name T, e.g. `auth`, `auth-internal`\n */\nexport class ComponentContainer {\n  private readonly providers = new Map<string, Provider<Name>>();\n\n  constructor(private readonly name: string) {}\n\n  /**\n   *\n   * @param component Component being added\n   * @param overwrite When a component with the same name has already been registered,\n   * if overwrite is true: overwrite the existing component with the new component and create a new\n   * provider with the new component. It can be useful in tests where you want to use different mocks\n   * for different tests.\n   * if overwrite is false: throw an exception\n   */\n  addComponent<T extends Name>(component: Component<T>): void {\n    const provider = this.getProvider(component.name);\n    if (provider.isComponentSet()) {\n      throw new Error(\n        `Component ${component.name} has already been registered with ${this.name}`\n      );\n    }\n\n    provider.setComponent(component);\n  }\n\n  addOrOverwriteComponent<T extends Name>(component: Component<T>): void {\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\n    this.addComponent(component);\n  }\n\n  /**\n   * getProvider provides a type safe interface where it can only be called with a field name\n   * present in NameServiceMapping interface.\n   *\n   * Firebase SDKs providing services should extend NameServiceMapping interface to register\n   * themselves.\n   */\n  getProvider<T extends Name>(name: T): Provider<T> {\n    if (this.providers.has(name)) {\n      return this.providers.get(name) as unknown as Provider<T>;\n    }\n\n    // create a Provider for a service that hasn't registered with Firebase\n    const provider = new Provider<T>(name, this);\n    this.providers.set(name, provider as unknown as Provider<Name>);\n\n    return provider as Provider<T>;\n  }\n\n  getProviders(): Array<Provider<Name>> {\n    return Array.from(this.providers.values());\n  }\n}\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport type LogLevelString =\n  | 'debug'\n  | 'verbose'\n  | 'info'\n  | 'warn'\n  | 'error'\n  | 'silent';\n\nexport interface LogOptions {\n  level: LogLevelString;\n}\n\nexport type LogCallback = (callbackParams: LogCallbackParams) => void;\n\nexport interface LogCallbackParams {\n  level: LogLevelString;\n  message: string;\n  args: unknown[];\n  type: string;\n}\n\n/**\n * A container for all of the Logger instances\n */\nexport const instances: Logger[] = [];\n\n/**\n * The JS SDK supports 5 log levels and also allows a user the ability to\n * silence the logs altogether.\n *\n * The order is a follows:\n * DEBUG < VERBOSE < INFO < WARN < ERROR\n *\n * All of the log types above the current log level will be captured (i.e. if\n * you set the log level to `INFO`, errors will still be logged, but `DEBUG` and\n * `VERBOSE` logs will not)\n */\nexport enum LogLevel {\n  DEBUG,\n  VERBOSE,\n  INFO,\n  WARN,\n  ERROR,\n  SILENT\n}\n\nconst levelStringToEnum: { [key in LogLevelString]: LogLevel } = {\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\n/**\n * The default log level\n */\nconst defaultLogLevel: LogLevel = LogLevel.INFO;\n\n/**\n * We allow users the ability to pass their own log handler. We will pass the\n * type of log, the current log level, and any other arguments passed (i.e. the\n * messages that the user wants to log) to this function.\n */\nexport type LogHandler = (\n  loggerInstance: Logger,\n  logType: LogLevel,\n  ...args: unknown[]\n) => void;\n\n/**\n * By default, `console.debug` is not displayed in the developer console (in\n * chrome). To avoid forcing users to have to opt-in to these logs twice\n * (i.e. once for firebase, and once in the console), we are sending `DEBUG`\n * logs to the `console.log` function.\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\n/**\n * The default log handler will forward DEBUG, VERBOSE, INFO, WARN, and ERROR\n * messages on to their corresponding console counterparts (if the log method\n * is supported by the current log level)\n */\nconst defaultLogHandler: LogHandler = (instance, logType, ...args): void => {\n  if (logType < instance.logLevel) {\n    return;\n  }\n  const now = new Date().toISOString();\n  const method = ConsoleMethod[logType as keyof typeof ConsoleMethod];\n  if (method) {\n    console[method as 'log' | 'info' | 'warn' | 'error'](\n      `[${now}]  ${instance.name}:`,\n      ...args\n    );\n  } else {\n    throw new Error(\n      `Attempted to log a message with an invalid logType (value: ${logType})`\n    );\n  }\n};\n\nexport class Logger {\n  /**\n   * Gives you an instance of a Logger to capture messages according to\n   * Firebase's logging scheme.\n   *\n   * @param name The name that the logs will be associated with\n   */\n  constructor(public name: string) {\n    /**\n     * Capture the current instance for later use\n     */\n    instances.push(this);\n  }\n\n  /**\n   * The log level of the given Logger instance.\n   */\n  private _logLevel = defaultLogLevel;\n\n  get logLevel(): LogLevel {\n    return this._logLevel;\n  }\n\n  set logLevel(val: LogLevel) {\n    if (!(val in LogLevel)) {\n      throw new TypeError(`Invalid value \"${val}\" assigned to \\`logLevel\\``);\n    }\n    this._logLevel = val;\n  }\n\n  // Workaround for setter/getter having to be the same type.\n  setLogLevel(val: LogLevel | LogLevelString): void {\n    this._logLevel = typeof val === 'string' ? levelStringToEnum[val] : val;\n  }\n\n  /**\n   * The main (internal) log handler for the Logger instance.\n   * Can be set to a new function in internal package code but not by user.\n   */\n  private _logHandler: LogHandler = defaultLogHandler;\n  get logHandler(): LogHandler {\n    return this._logHandler;\n  }\n  set logHandler(val: LogHandler) {\n    if (typeof val !== 'function') {\n      throw new TypeError('Value assigned to `logHandler` must be a function');\n    }\n    this._logHandler = val;\n  }\n\n  /**\n   * The optional, additional, user-defined log handler for the Logger instance.\n   */\n  private _userLogHandler: LogHandler | null = null;\n  get userLogHandler(): LogHandler | null {\n    return this._userLogHandler;\n  }\n  set userLogHandler(val: LogHandler | null) {\n    this._userLogHandler = val;\n  }\n\n  /**\n   * The functions below are all based on the `console` interface\n   */\n\n  debug(...args: unknown[]): void {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.DEBUG, ...args);\n    this._logHandler(this, LogLevel.DEBUG, ...args);\n  }\n  log(...args: unknown[]): void {\n    this._userLogHandler &&\n      this._userLogHandler(this, LogLevel.VERBOSE, ...args);\n    this._logHandler(this, LogLevel.VERBOSE, ...args);\n  }\n  info(...args: unknown[]): void {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.INFO, ...args);\n    this._logHandler(this, LogLevel.INFO, ...args);\n  }\n  warn(...args: unknown[]): void {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.WARN, ...args);\n    this._logHandler(this, LogLevel.WARN, ...args);\n  }\n  error(...args: unknown[]): void {\n    this._userLogHandler && this._userLogHandler(this, LogLevel.ERROR, ...args);\n    this._logHandler(this, LogLevel.ERROR, ...args);\n  }\n}\n\nexport function setLogLevel(level: LogLevelString | LogLevel): void {\n  instances.forEach(inst => {\n    inst.setLogLevel(level);\n  });\n}\n\nexport function setUserLogHandler(\n  logCallback: LogCallback | null,\n  options?: LogOptions\n): void {\n  for (const instance of instances) {\n    let customLogLevel: LogLevel | null = 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 = (\n        instance: Logger,\n        level: LogLevel,\n        ...args: unknown[]\n      ) => {\n        const message = args\n          .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          })\n          .filter(arg => arg)\n          .join(' ');\n        if (level >= (customLogLevel ?? instance.logLevel)) {\n          logCallback({\n            level: LogLevel[level].toLowerCase() as LogLevelString,\n            message,\n            args,\n            type: instance.name\n          });\n        }\n      };\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  ComponentContainer,\n  ComponentType,\n  Provider,\n  Name\n} from '@firebase/component';\nimport { PlatformLoggerService, VersionService } from './types';\n\nexport class PlatformLoggerServiceImpl implements PlatformLoggerService {\n  constructor(private readonly container: ComponentContainer) {}\n  // In initial implementation, this will be called by installations on\n  // auth token refresh, and installations will send this string.\n  getPlatformInfoString(): string {\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\n      .map(provider => {\n        if (isVersionServiceProvider(provider)) {\n          const service = provider.getImmediate() as VersionService;\n          return `${service.library}/${service.version}`;\n        } else {\n          return null;\n        }\n      })\n      .filter(logString => logString)\n      .join(' ');\n  }\n}\n/**\n *\n * @param provider check if this provider provides a VersionService\n *\n * NOTE: Using Provider<'app-version'> is a hack to indicate that the provider\n * provides VersionService. The provider is not necessarily a 'app-version'\n * provider.\n */\nfunction isVersionServiceProvider(provider: Provider<Name>): boolean {\n  const component = provider.getComponent();\n  return component?.type === ComponentType.VERSION;\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Logger } from '@firebase/logger';\n\nexport const logger = new Logger('@firebase/app');\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Component, ComponentType } from '@firebase/component';\nimport { PlatformLoggerServiceImpl } from './platformLoggerService';\nimport { name, version } from '../package.json';\nimport { _registerComponent } from './internal';\nimport { registerVersion } from './api';\nimport { HeartbeatServiceImpl } from './heartbeatService';\n\nexport function registerCoreComponents(variant?: string): void {\n  _registerComponent(\n    new Component(\n      'platform-logger',\n      container => new PlatformLoggerServiceImpl(container),\n      ComponentType.PRIVATE\n    )\n  );\n  _registerComponent(\n    new Component(\n      'heartbeat',\n      container => new HeartbeatServiceImpl(container),\n      ComponentType.PRIVATE\n    )\n  );\n\n  // Register `app` package.\n  registerVersion(name, version, variant);\n  // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation\n  registerVersion(name, version, '__BUILD_TARGET__');\n  // Register platform SDK identifier (no version).\n  registerVersion('fire-js', '');\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { name as appName } from '../package.json';\nimport { name as appCompatName } from '../../app-compat/package.json';\nimport { name as analyticsCompatName } from '../../../packages/analytics-compat/package.json';\nimport { name as analyticsName } from '../../../packages/analytics/package.json';\nimport { name as appCheckCompatName } from '../../../packages/app-check-compat/package.json';\nimport { name as appCheckName } from '../../../packages/app-check/package.json';\nimport { name as authName } from '../../../packages/auth/package.json';\nimport { name as authCompatName } from '../../../packages/auth-compat/package.json';\nimport { name as databaseName } from '../../../packages/database/package.json';\nimport { name as databaseCompatName } from '../../../packages/database-compat/package.json';\nimport { name as functionsName } from '../../../packages/functions/package.json';\nimport { name as functionsCompatName } from '../../../packages/functions-compat/package.json';\nimport { name as installationsName } from '../../../packages/installations/package.json';\nimport { name as installationsCompatName } from '../../../packages/installations-compat/package.json';\nimport { name as messagingName } from '../../../packages/messaging/package.json';\nimport { name as messagingCompatName } from '../../../packages/messaging-compat/package.json';\nimport { name as performanceName } from '../../../packages/performance/package.json';\nimport { name as performanceCompatName } from '../../../packages/performance-compat/package.json';\nimport { name as remoteConfigName } from '../../../packages/remote-config/package.json';\nimport { name as remoteConfigCompatName } from '../../../packages/remote-config-compat/package.json';\nimport { name as storageName } from '../../../packages/storage/package.json';\nimport { name as storageCompatName } from '../../../packages/storage-compat/package.json';\nimport { name as firestoreName } from '../../../packages/firestore/package.json';\nimport { name as firestoreCompatName } from '../../../packages/firestore-compat/package.json';\nimport { name as packageName } from '../../../packages/firebase/package.json';\n\n/**\n * The default app name\n *\n * @internal\n */\nexport const DEFAULT_ENTRY_NAME = '[DEFAULT]';\n\nexport const PLATFORM_LOG_STRING = {\n  [appName]: 'fire-core',\n  [appCompatName]: 'fire-core-compat',\n  [analyticsName]: 'fire-analytics',\n  [analyticsCompatName]: 'fire-analytics-compat',\n  [appCheckName]: 'fire-app-check',\n  [appCheckCompatName]: 'fire-app-check-compat',\n  [authName]: 'fire-auth',\n  [authCompatName]: 'fire-auth-compat',\n  [databaseName]: 'fire-rtdb',\n  [databaseCompatName]: 'fire-rtdb-compat',\n  [functionsName]: 'fire-fn',\n  [functionsCompatName]: 'fire-fn-compat',\n  [installationsName]: 'fire-iid',\n  [installationsCompatName]: 'fire-iid-compat',\n  [messagingName]: 'fire-fcm',\n  [messagingCompatName]: 'fire-fcm-compat',\n  [performanceName]: 'fire-perf',\n  [performanceCompatName]: 'fire-perf-compat',\n  [remoteConfigName]: 'fire-rc',\n  [remoteConfigCompatName]: 'fire-rc-compat',\n  [storageName]: 'fire-gcs',\n  [storageCompatName]: 'fire-gcs-compat',\n  [firestoreName]: 'fire-fst',\n  [firestoreCompatName]: 'fire-fst-compat',\n  'fire-js': 'fire-js', // Platform identifier for JS SDK.\n  [packageName]: 'fire-js-all'\n} as const;\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseApp } from './public-types';\nimport { Component, Provider, Name } from '@firebase/component';\nimport { logger } from './logger';\nimport { DEFAULT_ENTRY_NAME } from './constants';\nimport { FirebaseAppImpl } from './firebaseApp';\n\n/**\n * @internal\n */\nexport const _apps = new Map<string, FirebaseApp>();\n\n/**\n * Registered components.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const _components = new Map<string, Component<any>>();\n\n/**\n * @param component - the component being added to this app's container\n *\n * @internal\n */\nexport function _addComponent<T extends Name>(\n  app: FirebaseApp,\n  component: Component<T>\n): void {\n  try {\n    (app as FirebaseAppImpl).container.addComponent(component);\n  } catch (e) {\n    logger.debug(\n      `Component ${component.name} failed to register with FirebaseApp ${app.name}`,\n      e\n    );\n  }\n}\n\n/**\n *\n * @internal\n */\nexport function _addOrOverwriteComponent(\n  app: FirebaseApp,\n  component: Component\n): void {\n  (app as FirebaseAppImpl).container.addOrOverwriteComponent(component);\n}\n\n/**\n *\n * @param component - the component to register\n * @returns whether or not the component is registered successfully\n *\n * @internal\n */\nexport function _registerComponent<T extends Name>(\n  component: Component<T>\n): boolean {\n  const componentName = component.name;\n  if (_components.has(componentName)) {\n    logger.debug(\n      `There were multiple attempts to register component ${componentName}.`\n    );\n\n    return false;\n  }\n\n  _components.set(componentName, component);\n\n  // add the component to existing app instances\n  for (const app of _apps.values()) {\n    _addComponent(app as FirebaseAppImpl, component);\n  }\n\n  return true;\n}\n\n/**\n *\n * @param app - FirebaseApp instance\n * @param name - service name\n *\n * @returns the provider for the service with the matching name\n *\n * @internal\n */\nexport function _getProvider<T extends Name>(\n  app: FirebaseApp,\n  name: T\n): Provider<T> {\n  const heartbeatController = (app as FirebaseAppImpl).container\n    .getProvider('heartbeat')\n    .getImmediate({ optional: true });\n  if (heartbeatController) {\n    void heartbeatController.triggerHeartbeat();\n  }\n  return (app as FirebaseAppImpl).container.getProvider(name);\n}\n\n/**\n *\n * @param app - FirebaseApp instance\n * @param name - service name\n * @param instanceIdentifier - service instance identifier in case the service supports multiple instances\n *\n * @internal\n */\nexport function _removeServiceInstance<T extends Name>(\n  app: FirebaseApp,\n  name: T,\n  instanceIdentifier: string = DEFAULT_ENTRY_NAME\n): void {\n  _getProvider(app, name).clearInstance(instanceIdentifier);\n}\n\n/**\n * Test only\n *\n * @internal\n */\nexport function _clearComponents(): void {\n  _components.clear();\n}\n\n/**\n * Exported in order to be used in app-compat package\n */\nexport { DEFAULT_ENTRY_NAME as _DEFAULT_ENTRY_NAME };\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ErrorFactory, ErrorMap } from '@firebase/util';\n\nexport const enum AppError {\n  NO_APP = 'no-app',\n  BAD_APP_NAME = 'bad-app-name',\n  DUPLICATE_APP = 'duplicate-app',\n  APP_DELETED = 'app-deleted',\n  INVALID_APP_ARGUMENT = 'invalid-app-argument',\n  INVALID_LOG_ARGUMENT = 'invalid-log-argument',\n  STORAGE_OPEN = 'storage-open',\n  STORAGE_GET = 'storage-get',\n  STORAGE_WRITE = 'storage-set',\n  STORAGE_DELETE = 'storage-delete'\n}\n\nconst ERRORS: ErrorMap<AppError> = {\n  [AppError.NO_APP]:\n    \"No Firebase App '{$appName}' has been created - \" +\n    'call Firebase App.initializeApp()',\n  [AppError.BAD_APP_NAME]: \"Illegal App name: '{$appName}\",\n  [AppError.DUPLICATE_APP]:\n    \"Firebase App named '{$appName}' already exists with different options or config\",\n  [AppError.APP_DELETED]: \"Firebase App named '{$appName}' already deleted\",\n  [AppError.INVALID_APP_ARGUMENT]:\n    'firebase.{$appName}() takes either no argument or a ' +\n    'Firebase App instance.',\n  [AppError.INVALID_LOG_ARGUMENT]:\n    'First argument to `onLog` must be null or a function.',\n  [AppError.STORAGE_OPEN]:\n    'Error thrown when opening storage. Original error: {$originalErrorMessage}.',\n  [AppError.STORAGE_GET]:\n    'Error thrown when reading from storage. Original error: {$originalErrorMessage}.',\n  [AppError.STORAGE_WRITE]:\n    'Error thrown when writing to storage. Original error: {$originalErrorMessage}.',\n  [AppError.STORAGE_DELETE]:\n    'Error thrown when deleting from storage. Original error: {$originalErrorMessage}.'\n};\n\ninterface ErrorParams {\n  [AppError.NO_APP]: { appName: string };\n  [AppError.BAD_APP_NAME]: { appName: string };\n  [AppError.DUPLICATE_APP]: { appName: string };\n  [AppError.APP_DELETED]: { appName: string };\n  [AppError.INVALID_APP_ARGUMENT]: { appName: string };\n  [AppError.STORAGE_OPEN]: { originalErrorMessage?: string };\n  [AppError.STORAGE_GET]: { originalErrorMessage?: string };\n  [AppError.STORAGE_WRITE]: { originalErrorMessage?: string };\n  [AppError.STORAGE_DELETE]: { originalErrorMessage?: string };\n}\n\nexport const ERROR_FACTORY = new ErrorFactory<AppError, ErrorParams>(\n  'app',\n  'Firebase',\n  ERRORS\n);\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  FirebaseApp,\n  FirebaseOptions,\n  FirebaseAppSettings\n} from './public-types';\nimport {\n  ComponentContainer,\n  Component,\n  ComponentType\n} from '@firebase/component';\nimport { ERROR_FACTORY, AppError } from './errors';\n\nexport class FirebaseAppImpl implements FirebaseApp {\n  private readonly _options: FirebaseOptions;\n  private readonly _name: string;\n  /**\n   * Original config values passed in as a constructor parameter.\n   * It is only used to compare with another config object to support idempotent initializeApp().\n   *\n   * Updating automaticDataCollectionEnabled on the App instance will not change its value in _config.\n   */\n  private readonly _config: Required<FirebaseAppSettings>;\n  private _automaticDataCollectionEnabled: boolean;\n  private _isDeleted = false;\n  private readonly _container: ComponentContainer;\n\n  constructor(\n    options: FirebaseOptions,\n    config: Required<FirebaseAppSettings>,\n    container: ComponentContainer\n  ) {\n    this._options = { ...options };\n    this._config = { ...config };\n    this._name = config.name;\n    this._automaticDataCollectionEnabled =\n      config.automaticDataCollectionEnabled;\n    this._container = container;\n    this.container.addComponent(\n      new Component('app', () => this, ComponentType.PUBLIC)\n    );\n  }\n\n  get automaticDataCollectionEnabled(): boolean {\n    this.checkDestroyed();\n    return this._automaticDataCollectionEnabled;\n  }\n\n  set automaticDataCollectionEnabled(val: boolean) {\n    this.checkDestroyed();\n    this._automaticDataCollectionEnabled = val;\n  }\n\n  get name(): string {\n    this.checkDestroyed();\n    return this._name;\n  }\n\n  get options(): FirebaseOptions {\n    this.checkDestroyed();\n    return this._options;\n  }\n\n  get config(): Required<FirebaseAppSettings> {\n    this.checkDestroyed();\n    return this._config;\n  }\n\n  get container(): ComponentContainer {\n    return this._container;\n  }\n\n  get isDeleted(): boolean {\n    return this._isDeleted;\n  }\n\n  set isDeleted(val: boolean) {\n    this._isDeleted = val;\n  }\n\n  /**\n   * This function will throw an Error if the App has already been deleted -\n   * use before performing API actions on the App.\n   */\n  private checkDestroyed(): void {\n    if (this.isDeleted) {\n      throw ERROR_FACTORY.create(AppError.APP_DELETED, { appName: this._name });\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  FirebaseApp,\n  FirebaseOptions,\n  FirebaseAppSettings\n} from './public-types';\nimport { DEFAULT_ENTRY_NAME, PLATFORM_LOG_STRING } from './constants';\nimport { ERROR_FACTORY, AppError } from './errors';\nimport {\n  ComponentContainer,\n  Component,\n  Name,\n  ComponentType\n} from '@firebase/component';\nimport { version } from '../../firebase/package.json';\nimport { FirebaseAppImpl } from './firebaseApp';\nimport { _apps, _components, _registerComponent } from './internal';\nimport { logger } from './logger';\nimport {\n  LogLevelString,\n  setLogLevel as setLogLevelImpl,\n  LogCallback,\n  LogOptions,\n  setUserLogHandler\n} from '@firebase/logger';\nimport { deepEqual } from '@firebase/util';\n\nexport { FirebaseError } from '@firebase/util';\n\n/**\n * The current SDK version.\n *\n * @public\n */\nexport const SDK_VERSION = version;\n\n/**\n * Creates and initializes a {@link @firebase/app#FirebaseApp} instance.\n *\n * See\n * {@link\n *   https://firebase.google.com/docs/web/setup#add_firebase_to_your_app\n *   | Add Firebase to your app} and\n * {@link\n *   https://firebase.google.com/docs/web/setup#multiple-projects\n *   | Initialize multiple projects} for detailed documentation.\n *\n * @example\n * ```javascript\n *\n * // Initialize default app\n * // Retrieve your own options values by adding a web app on\n * // https://console.firebase.google.com\n * initializeApp({\n *   apiKey: \"AIza....\",                             // Auth / General Use\n *   authDomain: \"YOUR_APP.firebaseapp.com\",         // Auth with popup/redirect\n *   databaseURL: \"https://YOUR_APP.firebaseio.com\", // Realtime Database\n *   storageBucket: \"YOUR_APP.appspot.com\",          // Storage\n *   messagingSenderId: \"123456789\"                  // Cloud Messaging\n * });\n * ```\n *\n * @example\n * ```javascript\n *\n * // Initialize another app\n * const otherApp = initializeApp({\n *   databaseURL: \"https://<OTHER_DATABASE_NAME>.firebaseio.com\",\n *   storageBucket: \"<OTHER_STORAGE_BUCKET>.appspot.com\"\n * }, \"otherApp\");\n * ```\n *\n * @param options - Options to configure the app's services.\n * @param name - Optional name of the app to initialize. If no name\n *   is provided, the default is `\"[DEFAULT]\"`.\n *\n * @returns The initialized app.\n *\n * @public\n */\nexport function initializeApp(\n  options: FirebaseOptions,\n  name?: string\n): FirebaseApp;\n/**\n * Creates and initializes a FirebaseApp instance.\n *\n * @param options - Options to configure the app's services.\n * @param config - FirebaseApp Configuration\n *\n * @public\n */\nexport function initializeApp(\n  options: FirebaseOptions,\n  config?: FirebaseAppSettings\n): FirebaseApp;\nexport function initializeApp(\n  options: FirebaseOptions,\n  rawConfig = {}\n): FirebaseApp {\n  if (typeof rawConfig !== 'object') {\n    const name = rawConfig;\n    rawConfig = { name };\n  }\n\n  const config: Required<FirebaseAppSettings> = {\n    name: DEFAULT_ENTRY_NAME,\n    automaticDataCollectionEnabled: false,\n    ...rawConfig\n  };\n  const name = config.name;\n\n  if (typeof name !== 'string' || !name) {\n    throw ERROR_FACTORY.create(AppError.BAD_APP_NAME, {\n      appName: String(name)\n    });\n  }\n\n  const existingApp = _apps.get(name) as FirebaseAppImpl;\n  if (existingApp) {\n    // return the existing app if options and config deep equal the ones in the existing app.\n    if (\n      deepEqual(options, existingApp.options) &&\n      deepEqual(config, existingApp.config)\n    ) {\n      return existingApp;\n    } else {\n      throw ERROR_FACTORY.create(AppError.DUPLICATE_APP, { appName: name });\n    }\n  }\n\n  const container = new ComponentContainer(name);\n  for (const component of _components.values()) {\n    container.addComponent(component);\n  }\n\n  const newApp = new FirebaseAppImpl(options, config, container);\n\n  _apps.set(name, newApp);\n\n  return newApp;\n}\n\n/**\n * Retrieves a {@link @firebase/app#FirebaseApp} instance.\n *\n * When called with no arguments, the default app is returned. When an app name\n * is provided, the app corresponding to that name is returned.\n *\n * An exception is thrown if the app being retrieved has not yet been\n * initialized.\n *\n * @example\n * ```javascript\n * // Return the default app\n * const app = getApp();\n * ```\n *\n * @example\n * ```javascript\n * // Return a named app\n * const otherApp = getApp(\"otherApp\");\n * ```\n *\n * @param name - Optional name of the app to return. If no name is\n *   provided, the default is `\"[DEFAULT]\"`.\n *\n * @returns The app corresponding to the provided app name.\n *   If no app name is provided, the default app is returned.\n *\n * @public\n */\nexport function getApp(name: string = DEFAULT_ENTRY_NAME): FirebaseApp {\n  const app = _apps.get(name);\n  if (!app) {\n    throw ERROR_FACTORY.create(AppError.NO_APP, { appName: name });\n  }\n\n  return app;\n}\n\n/**\n * A (read-only) array of all initialized apps.\n * @public\n */\nexport function getApps(): FirebaseApp[] {\n  return Array.from(_apps.values());\n}\n\n/**\n * Renders this app unusable and frees the resources of all associated\n * services.\n *\n * @example\n * ```javascript\n * deleteApp(app)\n *   .then(function() {\n *     console.log(\"App deleted successfully\");\n *   })\n *   .catch(function(error) {\n *     console.log(\"Error deleting app:\", error);\n *   });\n * ```\n *\n * @public\n */\nexport async function deleteApp(app: FirebaseApp): Promise<void> {\n  const name = app.name;\n  if (_apps.has(name)) {\n    _apps.delete(name);\n    await Promise.all(\n      (app as FirebaseAppImpl).container\n        .getProviders()\n        .map(provider => provider.delete())\n    );\n    (app as FirebaseAppImpl).isDeleted = true;\n  }\n}\n\n/**\n * Registers a library's name and version for platform logging purposes.\n * @param library - Name of 1p or 3p library (e.g. firestore, angularfire)\n * @param version - Current version of that library.\n * @param variant - Bundle variant, e.g., node, rn, etc.\n *\n * @public\n */\nexport function registerVersion(\n  libraryKeyOrName: string,\n  version: string,\n  variant?: string\n): void {\n  // TODO: We can use this check to whitelist strings when/if we set up\n  // a good whitelist system.\n  let library = PLATFORM_LOG_STRING[libraryKeyOrName] ?? 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 = [\n      `Unable to register library \"${library}\" with version \"${version}\":`\n    ];\n    if (libraryMismatch) {\n      warning.push(\n        `library name \"${library}\" contains illegal characters (whitespace or \"/\")`\n      );\n    }\n    if (libraryMismatch && versionMismatch) {\n      warning.push('and');\n    }\n    if (versionMismatch) {\n      warning.push(\n        `version name \"${version}\" contains illegal characters (whitespace or \"/\")`\n      );\n    }\n    logger.warn(warning.join(' '));\n    return;\n  }\n  _registerComponent(\n    new Component(\n      `${library}-version` as Name,\n      () => ({ library, version }),\n      ComponentType.VERSION\n    )\n  );\n}\n\n/**\n * Sets log handler for all Firebase SDKs.\n * @param logCallback - An optional custom log handler that executes user code whenever\n * the Firebase SDK makes a logging call.\n *\n * @public\n */\nexport function onLog(\n  logCallback: LogCallback | null,\n  options?: LogOptions\n): void {\n  if (logCallback !== null && typeof logCallback !== 'function') {\n    throw ERROR_FACTORY.create(AppError.INVALID_LOG_ARGUMENT);\n  }\n  setUserLogHandler(logCallback, options);\n}\n\n/**\n * Sets log level for all Firebase SDKs.\n *\n * All of the log types above the current log level are captured (i.e. if\n * you set the log level to `info`, errors are logged, but `debug` and\n * `verbose` logs are not).\n *\n * @public\n */\nexport function setLogLevel(logLevel: LogLevelString): void {\n  setLogLevelImpl(logLevel);\n}\n","/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { DBWrapper, openDB } from '@firebase/util';\nimport { AppError, ERROR_FACTORY } from './errors';\nimport { FirebaseApp } from './public-types';\nimport { HeartbeatsInIndexedDB } from './types';\nconst DB_NAME = 'firebase-heartbeat-database';\nconst DB_VERSION = 1;\nconst STORE_NAME = 'firebase-heartbeat-store';\n\nlet dbPromise: Promise<DBWrapper> | null = null;\nfunction getDbPromise(): Promise<DBWrapper> {\n  if (!dbPromise) {\n    dbPromise = openDB(DB_NAME, DB_VERSION, (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    }).catch(e => {\n      throw ERROR_FACTORY.create(AppError.STORAGE_OPEN, {\n        originalErrorMessage: e.message\n      });\n    });\n  }\n  return dbPromise;\n}\n\nexport async function readHeartbeatsFromIndexedDB(\n  app: FirebaseApp\n): Promise<HeartbeatsInIndexedDB | undefined> {\n  try {\n    const db = await getDbPromise();\n    return db\n      .transaction(STORE_NAME)\n      .objectStore(STORE_NAME)\n      .get(computeKey(app)) as Promise<HeartbeatsInIndexedDB | undefined>;\n  } catch (e) {\n    throw ERROR_FACTORY.create(AppError.STORAGE_GET, {\n      originalErrorMessage: e.message\n    });\n  }\n}\n\nexport async function writeHeartbeatsToIndexedDB(\n  app: FirebaseApp,\n  heartbeatObject: HeartbeatsInIndexedDB\n): Promise<void> {\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    return tx.complete;\n  } catch (e) {\n    throw ERROR_FACTORY.create(AppError.STORAGE_WRITE, {\n      originalErrorMessage: e.message\n    });\n  }\n}\n\nfunction computeKey(app: FirebaseApp): string {\n  return `${app.name}!${app.options.appId}`;\n}\n","/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ComponentContainer } from '@firebase/component';\nimport {\n  base64urlEncodeWithoutPadding,\n  isIndexedDBAvailable,\n  validateIndexedDBOpenable\n} from '@firebase/util';\nimport {\n  readHeartbeatsFromIndexedDB,\n  writeHeartbeatsToIndexedDB\n} from './indexeddb';\nimport { FirebaseApp } from './public-types';\nimport {\n  HeartbeatsByUserAgent,\n  HeartbeatService,\n  HeartbeatsInIndexedDB,\n  HeartbeatStorage,\n  SingleDateHeartbeat\n} from './types';\n\nconst MAX_HEADER_BYTES = 1024;\n// 30 days\nconst STORED_HEARTBEAT_RETENTION_MAX_MILLIS = 30 * 24 * 60 * 60 * 1000;\n\nexport class HeartbeatServiceImpl implements HeartbeatService {\n  /**\n   * The persistence layer for heartbeats\n   * Leave public for easier testing.\n   */\n  _storage: HeartbeatStorageImpl;\n\n  /**\n   * In-memory cache for heartbeats, used by getHeartbeatsHeader() to generate\n   * the header string.\n   * Stores one record per date. This will be consolidated into the standard\n   * format of one record per user agent string before being sent as a header.\n   * Populated from indexedDB when the controller is instantiated and should\n   * be kept in sync with indexedDB.\n   * Leave public for easier testing.\n   */\n  _heartbeatsCache: HeartbeatsInIndexedDB | null = null;\n\n  /**\n   * the initialization promise for populating heartbeatCache.\n   * If getHeartbeatsHeader() is called before the promise resolves\n   * (hearbeatsCache == null), it should wait for this promise\n   * Leave public for easier testing.\n   */\n  _heartbeatsCachePromise: Promise<HeartbeatsInIndexedDB>;\n  constructor(private readonly container: ComponentContainer) {\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\n  /**\n   * Called to report a heartbeat. The function will generate\n   * a HeartbeatsByUserAgent object, update heartbeatsCache, and persist it\n   * to IndexedDB.\n   * Note that we only store one heartbeat per day. So if a heartbeat for today is\n   * already logged, subsequent calls to this function in the same day will be ignored.\n   */\n  async triggerHeartbeat(): Promise<void> {\n    const platformLogger = this.container\n      .getProvider('platform-logger')\n      .getImmediate();\n\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 (this._heartbeatsCache === null) {\n      this._heartbeatsCache = await this._heartbeatsCachePromise;\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 (\n      this._heartbeatsCache.lastSentHeartbeatDate === date ||\n      this._heartbeatsCache.heartbeats.some(\n        singleDateHeartbeat => singleDateHeartbeat.date === date\n      )\n    ) {\n      return;\n    } else {\n      // There is no entry for this date. Create one.\n      this._heartbeatsCache.heartbeats.push({ date, agent });\n    }\n    // Remove entries older than 30 days.\n    this._heartbeatsCache.heartbeats = this._heartbeatsCache.heartbeats.filter(\n      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    );\n    return this._storage.overwrite(this._heartbeatsCache);\n  }\n\n  /**\n   * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly.\n   * It also clears all heartbeats from memory as well as in IndexedDB.\n   *\n   * NOTE: Consuming product SDKs should not send the header if this method\n   * returns an empty string.\n   */\n  async getHeartbeatsHeader(): Promise<string> {\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 (\n      this._heartbeatsCache === null ||\n      this._heartbeatsCache.heartbeats.length === 0\n    ) {\n      return '';\n    }\n    const date = getUTCDateString();\n    // Extract as many heartbeats from the cache as will fit under the size limit.\n    const { heartbeatsToSend, unsentEntries } = extractHeartbeatsForHeader(\n      this._heartbeatsCache.heartbeats\n    );\n    const headerString = base64urlEncodeWithoutPadding(\n      JSON.stringify({ version: 2, 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}\n\nfunction getUTCDateString(): string {\n  const today = new Date();\n  // Returns date format 'YYYY-MM-DD'\n  return today.toISOString().substring(0, 10);\n}\n\nexport function extractHeartbeatsForHeader(\n  heartbeatsCache: SingleDateHeartbeat[],\n  maxSize = MAX_HEADER_BYTES\n): {\n  heartbeatsToSend: HeartbeatsByUserAgent[];\n  unsentEntries: SingleDateHeartbeat[];\n} {\n  // Heartbeats grouped by user agent in the standard format to be sent in\n  // the header.\n  const heartbeatsToSend: HeartbeatsByUserAgent[] = [];\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(\n      hb => hb.agent === singleDateHeartbeat.agent\n    );\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}\n\nexport class HeartbeatStorageImpl implements HeartbeatStorage {\n  private _canUseIndexedDBPromise: Promise<boolean>;\n  constructor(public app: FirebaseApp) {\n    this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();\n  }\n  async runIndexedDBEnvironmentCheck(): Promise<boolean> {\n    if (!isIndexedDBAvailable()) {\n      return false;\n    } else {\n      return validateIndexedDBOpenable()\n        .then(() => true)\n        .catch(() => false);\n    }\n  }\n  /**\n   * Read all heartbeats.\n   */\n  async read(): Promise<HeartbeatsInIndexedDB> {\n    const canUseIndexedDB = await this._canUseIndexedDBPromise;\n    if (!canUseIndexedDB) {\n      return { heartbeats: [] };\n    } else {\n      const idbHeartbeatObject = await readHeartbeatsFromIndexedDB(this.app);\n      return idbHeartbeatObject || { heartbeats: [] };\n    }\n  }\n  // overwrite the storage with the provided heartbeats\n  async overwrite(heartbeatsObject: HeartbeatsInIndexedDB): Promise<void> {\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:\n          heartbeatsObject.lastSentHeartbeatDate ??\n          existingHeartbeatsObject.lastSentHeartbeatDate,\n        heartbeats: heartbeatsObject.heartbeats\n      });\n    }\n  }\n  // add heartbeats\n  async add(heartbeatsObject: HeartbeatsInIndexedDB): Promise<void> {\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:\n          heartbeatsObject.lastSentHeartbeatDate ??\n          existingHeartbeatsObject.lastSentHeartbeatDate,\n        heartbeats: [\n          ...existingHeartbeatsObject.heartbeats,\n          ...heartbeatsObject.heartbeats\n        ]\n      });\n    }\n  }\n}\n\n/**\n * Calculate bytes of a HeartbeatsByUserAgent array after being wrapped\n * in a platform logging header JSON object, stringified, and converted\n * to base 64.\n */\nexport function countBytes(heartbeatsCache: HeartbeatsByUserAgent[]): number {\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({ version: 2, heartbeats: heartbeatsCache })\n  ).length;\n}\n","/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { CONSTANTS } from './constants';\n\n/**\n * Returns navigator.userAgent string or '' if it's not defined.\n * @return user agent string\n */\nexport function getUA(): string {\n  if (\n    typeof navigator !== 'undefined' &&\n    typeof navigator['userAgent'] === 'string'\n  ) {\n    return navigator['userAgent'];\n  } else {\n    return '';\n  }\n}\n\n/**\n * Detect Cordova / PhoneGap / Ionic frameworks on a mobile device.\n *\n * Deliberately does not rely on checking `file://` URLs (as this fails PhoneGap\n * in the Ripple emulator) nor Cordova `onDeviceReady`, which would normally\n * wait for a callback.\n */\nexport function isMobileCordova(): boolean {\n  return (\n    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']) &&\n    /ios|iphone|ipod|ipad|android|blackberry|iemobile/i.test(getUA())\n  );\n}\n\n/**\n * Detect Node.js.\n *\n * @return true if Node.js environment is detected.\n */\n// Node detection logic from: https://github.com/iliakan/detect-node/\nexport function isNode(): boolean {\n  try {\n    return (\n      Object.prototype.toString.call(global.process) === '[object process]'\n    );\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Detect Browser Environment\n */\nexport function isBrowser(): boolean {\n  return typeof self === 'object' && self.self === self;\n}\n\n/**\n * Detect browser extensions (Chrome and Firefox at least).\n */\ninterface BrowserRuntime {\n  id?: unknown;\n}\ndeclare const chrome: { runtime?: BrowserRuntime };\ndeclare const browser: { runtime?: BrowserRuntime };\nexport function isBrowserExtension(): boolean {\n  const runtime =\n    typeof chrome === 'object'\n      ? chrome.runtime\n      : typeof browser === 'object'\n      ? browser.runtime\n      : undefined;\n  return typeof runtime === 'object' && runtime.id !== undefined;\n}\n\n/**\n * Detect React Native.\n *\n * @return true if ReactNative environment is detected.\n */\nexport function isReactNative(): boolean {\n  return (\n    typeof navigator === 'object' && navigator['product'] === 'ReactNative'\n  );\n}\n\n/** Detects Electron apps. */\nexport function isElectron(): boolean {\n  return getUA().indexOf('Electron/') >= 0;\n}\n\n/** Detects Internet Explorer. */\nexport function isIE(): boolean {\n  const ua = getUA();\n  return ua.indexOf('MSIE ') >= 0 || ua.indexOf('Trident/') >= 0;\n}\n\n/** Detects Universal Windows Platform apps. */\nexport function isUWP(): boolean {\n  return getUA().indexOf('MSAppHost/') >= 0;\n}\n\n/**\n * Detect whether the current SDK build is the Node version.\n *\n * @return true if it's the Node SDK build.\n */\nexport function isNodeSdk(): boolean {\n  return CONSTANTS.NODE_CLIENT === true || CONSTANTS.NODE_ADMIN === true;\n}\n\n/** Returns true if we are running in Safari. */\nexport function isSafari(): boolean {\n  return (\n    !isNode() &&\n    navigator.userAgent.includes('Safari') &&\n    !navigator.userAgent.includes('Chrome')\n  );\n}\n\n/**\n * This method checks if indexedDB is supported by current browser/service worker context\n * @return true if indexedDB is supported by current browser/service worker context\n */\nexport function isIndexedDBAvailable(): boolean {\n  return typeof indexedDB === 'object';\n}\n\n/**\n * This method validates browser/sw context for indexedDB by opening a dummy indexedDB database and reject\n * if errors occur during the database open operation.\n *\n * @throws exception if current browser/sw context can't run idb.open (ex: Safari iframe, Firefox\n * private browsing)\n */\nexport function validateIndexedDBOpenable(): Promise<boolean> {\n  return new Promise((resolve, reject) => {\n    try {\n      let preExist: boolean = true;\n      const DB_CHECK_NAME =\n        '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\n      request.onerror = () => {\n        reject(request.error?.message || '');\n      };\n    } catch (error) {\n      reject(error);\n    }\n  });\n}\n\n/**\n *\n * This method checks whether cookie is enabled within current browser\n * @return true if cookie is enabled within current browser\n */\nexport function areCookiesEnabled(): boolean {\n  if (typeof navigator === 'undefined' || !navigator.cookieEnabled) {\n    return false;\n  }\n  return true;\n}\n\n/**\n * Polyfill for `globalThis` object.\n * @returns the `globalThis` object for the given environment.\n */\nexport function getGlobal(): typeof globalThis {\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 * Firebase App\n *\n * @remarks This package coordinates the communication between the different Firebase components\n * @packageDocumentation\n */\n\n/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { registerCoreComponents } from './registerCoreComponents';\n\nexport * from './api';\nexport * from './internal';\nexport * from './public-types';\n\nregisterCoreComponents('__RUNTIME_ENV__');\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseOptions } from './public-types';\nimport {\n  Component,\n  ComponentContainer,\n  ComponentType,\n  InstantiationMode,\n  Name\n} from '@firebase/component';\nimport {\n  deleteApp,\n  _addComponent,\n  _addOrOverwriteComponent,\n  _DEFAULT_ENTRY_NAME,\n  _FirebaseAppInternal as _FirebaseAppExp\n} from '@firebase/app';\nimport { _FirebaseService, _FirebaseNamespace } from './types';\nimport { Compat } from '@firebase/util';\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport interface _FirebaseApp {\n  /**\n   * The (read-only) name (identifier) for this App. '[DEFAULT]' is the default\n   * App.\n   */\n  name: string;\n\n  /**\n   * The (read-only) configuration options from the app initialization.\n   */\n  options: FirebaseOptions;\n\n  /**\n   * The settable config flag for GDPR opt-in/opt-out\n   */\n  automaticDataCollectionEnabled: boolean;\n\n  /**\n   * Make the given App unusable and free resources.\n   */\n  delete(): Promise<void>;\n}\n/**\n * Global context object for a collection of services using\n * a shared authentication state.\n *\n * marked as internal because it references internal types exported from @firebase/app\n * @internal\n */\nexport class FirebaseAppImpl implements Compat<_FirebaseAppExp>, _FirebaseApp {\n  private container: ComponentContainer;\n\n  constructor(\n    readonly _delegate: _FirebaseAppExp,\n    private readonly firebase: _FirebaseNamespace\n  ) {\n    // add itself to container\n    _addComponent(\n      _delegate,\n      new Component('app-compat', () => this, ComponentType.PUBLIC)\n    );\n\n    this.container = _delegate.container;\n  }\n\n  get automaticDataCollectionEnabled(): boolean {\n    return this._delegate.automaticDataCollectionEnabled;\n  }\n\n  set automaticDataCollectionEnabled(val) {\n    this._delegate.automaticDataCollectionEnabled = val;\n  }\n\n  get name(): string {\n    return this._delegate.name;\n  }\n\n  get options(): FirebaseOptions {\n    return this._delegate.options;\n  }\n\n  delete(): Promise<void> {\n    return new Promise<void>(resolve => {\n      this._delegate.checkDestroyed();\n      resolve();\n    }).then(() => {\n      this.firebase.INTERNAL.removeApp(this.name);\n      return deleteApp(this._delegate);\n    });\n  }\n\n  /**\n   * Return a service instance associated with this app (creating it\n   * on demand), identified by the passed instanceIdentifier.\n   *\n   * NOTE: Currently storage and functions are the only ones that are leveraging this\n   * functionality. They invoke it by calling:\n   *\n   * ```javascript\n   * firebase.app().storage('STORAGE BUCKET ID')\n   * ```\n   *\n   * The service name is passed to this already\n   * @internal\n   */\n  _getService(\n    name: string,\n    instanceIdentifier: string = _DEFAULT_ENTRY_NAME\n  ): _FirebaseService {\n    this._delegate.checkDestroyed();\n\n    // Initialize instance if InstatiationMode is `EXPLICIT`.\n    const provider = this._delegate.container.getProvider(name as Name);\n    if (\n      !provider.isInitialized() &&\n      provider.getComponent()?.instantiationMode === InstantiationMode.EXPLICIT\n    ) {\n      provider.initialize();\n    }\n\n    // getImmediate will always succeed because _getService is only called for registered components.\n    return provider.getImmediate({\n      identifier: instanceIdentifier\n    }) as unknown as _FirebaseService;\n  }\n\n  /**\n   * Remove a service instance from the cache, so we will create a new instance for this service\n   * when people try to get it again.\n   *\n   * NOTE: currently only firestore uses this functionality to support firestore shutdown.\n   *\n   * @param name The service name\n   * @param instanceIdentifier instance identifier in case multiple instances are allowed\n   * @internal\n   */\n  _removeServiceInstance(\n    name: string,\n    instanceIdentifier: string = _DEFAULT_ENTRY_NAME\n  ): void {\n    this._delegate.container\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      .getProvider(name as any)\n      .clearInstance(instanceIdentifier);\n  }\n\n  /**\n   * @param component the component being added to this app's container\n   * @internal\n   */\n  _addComponent(component: Component): void {\n    _addComponent(this._delegate, component);\n  }\n\n  _addOrOverwriteComponent(component: Component): void {\n    _addOrOverwriteComponent(this._delegate, component);\n  }\n\n  toJSON(): object {\n    return {\n      name: this.name,\n      automaticDataCollectionEnabled: this.automaticDataCollectionEnabled,\n      options: this.options\n    };\n  }\n}\n\n// TODO: investigate why the following needs to be commented out\n// Prevent dead-code elimination of these methods w/o invalid property\n// copying.\n// (FirebaseAppImpl.prototype.name && FirebaseAppImpl.prototype.options) ||\n//   FirebaseAppImpl.prototype.delete ||\n//   console.log('dc');\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ErrorFactory, ErrorMap } from '@firebase/util';\n\nexport const enum AppError {\n  NO_APP = 'no-app',\n  INVALID_APP_ARGUMENT = 'invalid-app-argument'\n}\n\nconst ERRORS: ErrorMap<AppError> = {\n  [AppError.NO_APP]:\n    \"No Firebase App '{$appName}' has been created - \" +\n    'call Firebase App.initializeApp()',\n  [AppError.INVALID_APP_ARGUMENT]:\n    'firebase.{$appName}() takes either no argument or a ' +\n    'Firebase App instance.'\n};\n\ntype ErrorParams = { [key in AppError]: { appName: string } };\n\nexport const ERROR_FACTORY = new ErrorFactory<AppError, ErrorParams>(\n  'app-compat',\n  'Firebase',\n  ERRORS\n);\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseApp, FirebaseOptions } from './public-types';\nimport {\n  _FirebaseNamespace,\n  _FirebaseService,\n  FirebaseServiceNamespace\n} from './types';\nimport * as modularAPIs from '@firebase/app';\nimport { _FirebaseAppInternal as _FirebaseAppExp } from '@firebase/app';\nimport { Component, ComponentType, Name } from '@firebase/component';\n\nimport { deepExtend, contains } from '@firebase/util';\nimport { FirebaseAppImpl } from './firebaseApp';\nimport { ERROR_FACTORY, AppError } from './errors';\nimport { FirebaseAppLiteImpl } from './lite/firebaseAppLite';\n\n/**\n * Because auth can't share code with other components, we attach the utility functions\n * in an internal namespace to share code.\n * This function return a firebase namespace object without\n * any utility functions, so it can be shared between the regular firebaseNamespace and\n * the lite version.\n */\nexport function createFirebaseNamespaceCore(\n  firebaseAppImpl: typeof FirebaseAppImpl | typeof FirebaseAppLiteImpl\n): _FirebaseNamespace {\n  const apps: { [name: string]: FirebaseApp } = {};\n  // // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  // const components = new Map<string, Component<any>>();\n\n  // A namespace is a plain JavaScript Object.\n  const namespace: _FirebaseNamespace = {\n    // Hack to prevent Babel from modifying the object returned\n    // as the firebase namespace.\n    // @ts-ignore\n    __esModule: true,\n    initializeApp: initializeAppCompat,\n    // @ts-ignore\n    app,\n    registerVersion: modularAPIs.registerVersion,\n    setLogLevel: modularAPIs.setLogLevel,\n    onLog: modularAPIs.onLog,\n    // @ts-ignore\n    apps: null,\n    SDK_VERSION: modularAPIs.SDK_VERSION,\n    INTERNAL: {\n      registerComponent: registerComponentCompat,\n      removeApp,\n      useAsService,\n      modularAPIs\n    }\n  };\n\n  // Inject a circular default export to allow Babel users who were previously\n  // using:\n  //\n  //   import firebase from 'firebase';\n  //   which becomes: var firebase = require('firebase').default;\n  //\n  // instead of\n  //\n  //   import * as firebase from 'firebase';\n  //   which becomes: var firebase = require('firebase');\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  (namespace as any)['default'] = namespace;\n\n  // firebase.apps is a read-only getter.\n  Object.defineProperty(namespace, 'apps', {\n    get: getApps\n  });\n\n  /**\n   * Called by App.delete() - but before any services associated with the App\n   * are deleted.\n   */\n  function removeApp(name: string): void {\n    delete apps[name];\n  }\n\n  /**\n   * Get the App object for a given name (or DEFAULT).\n   */\n  function app(name?: string): FirebaseApp {\n    name = name || modularAPIs._DEFAULT_ENTRY_NAME;\n    if (!contains(apps, name)) {\n      throw ERROR_FACTORY.create(AppError.NO_APP, { appName: name });\n    }\n    return apps[name];\n  }\n\n  // @ts-ignore\n  app['App'] = firebaseAppImpl;\n\n  /**\n   * Create a new App instance (name must be unique).\n   *\n   * This function is idempotent. It can be called more than once and return the same instance using the same options and config.\n   */\n  function initializeAppCompat(\n    options: FirebaseOptions,\n    rawConfig = {}\n  ): FirebaseApp {\n    const app = modularAPIs.initializeApp(\n      options,\n      rawConfig\n    ) as _FirebaseAppExp;\n\n    if (contains(apps, app.name)) {\n      return apps[app.name];\n    }\n\n    const appCompat = new firebaseAppImpl(app, namespace);\n    apps[app.name] = appCompat;\n    return appCompat;\n  }\n\n  /*\n   * Return an array of all the non-deleted FirebaseApps.\n   */\n  function getApps(): FirebaseApp[] {\n    // Make a copy so caller cannot mutate the apps list.\n    return Object.keys(apps).map(name => apps[name]);\n  }\n\n  function registerComponentCompat<T extends Name>(\n    component: Component<T>\n  ): FirebaseServiceNamespace<_FirebaseService> | null {\n    const componentName = component.name;\n    const componentNameWithoutCompat = componentName.replace('-compat', '');\n    if (\n      modularAPIs._registerComponent(component) &&\n      component.type === ComponentType.PUBLIC\n    ) {\n      // create service namespace for public components\n      // The Service namespace is an accessor function ...\n      const serviceNamespace = (\n        appArg: FirebaseApp = app()\n      ): _FirebaseService => {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        if (typeof (appArg as any)[componentNameWithoutCompat] !== 'function') {\n          // Invalid argument.\n          // This happens in the following case: firebase.storage('gs:/')\n          throw ERROR_FACTORY.create(AppError.INVALID_APP_ARGUMENT, {\n            appName: componentName\n          });\n        }\n\n        // Forward service instance lookup to the FirebaseApp.\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return (appArg as any)[componentNameWithoutCompat]();\n      };\n\n      // ... and a container for service-level properties.\n      if (component.serviceProps !== undefined) {\n        deepExtend(serviceNamespace, component.serviceProps);\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      (namespace as any)[componentNameWithoutCompat] = serviceNamespace;\n\n      // Patch the FirebaseAppImpl prototype\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      (firebaseAppImpl.prototype as any)[componentNameWithoutCompat] =\n        // TODO: The eslint disable can be removed and the 'ignoreRestArgs'\n        // option added to the no-explicit-any rule when ESlint releases it.\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        function (...args: any) {\n          const serviceFxn = this._getService.bind(this, componentName);\n          return serviceFxn.apply(\n            this,\n            component.multipleInstances ? args : []\n          );\n        };\n    }\n\n    return component.type === ComponentType.PUBLIC\n      ? // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        (namespace as any)[componentNameWithoutCompat]\n      : null;\n  }\n\n  // Map the requested service to a registered service name\n  // (used to map auth to serverAuth service when needed).\n  function useAsService(app: FirebaseApp, name: string): string | null {\n    if (name === 'serverAuth') {\n      return null;\n    }\n\n    const useService = name;\n\n    return useService;\n  }\n\n  return namespace;\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseNamespace } from './public-types';\nimport { createSubscribe, deepExtend, ErrorFactory } from '@firebase/util';\nimport { FirebaseAppImpl } from './firebaseApp';\nimport { createFirebaseNamespaceCore } from './firebaseNamespaceCore';\n\n/**\n * Return a firebase namespace object.\n *\n * In production, this will be called exactly once and the result\n * assigned to the 'firebase' global.  It may be called multiple times\n * in unit tests.\n */\nexport function createFirebaseNamespace(): FirebaseNamespace {\n  const namespace = createFirebaseNamespaceCore(FirebaseAppImpl);\n  namespace.INTERNAL = {\n    ...namespace.INTERNAL,\n    createFirebaseNamespace,\n    extendNamespace,\n    createSubscribe,\n    ErrorFactory,\n    deepExtend\n  };\n\n  /**\n   * Patch the top-level firebase namespace with additional properties.\n   *\n   * firebase.INTERNAL.extendNamespace()\n   */\n  function extendNamespace(props: { [prop: string]: unknown }): void {\n    deepExtend(namespace, props);\n  }\n\n  return namespace;\n}\n\nexport const firebase = createFirebaseNamespace();\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Logger } from '@firebase/logger';\n\nexport const logger = new Logger('@firebase/app-compat');\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseNamespace } from './public-types';\nimport { isBrowser } from '@firebase/util';\nimport { firebase as firebaseNamespace } from './firebaseNamespace';\nimport { logger } from './logger';\nimport { registerCoreComponents } from './registerCoreComponents';\n\n// Firebase Lite detection\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nif (isBrowser() && (self as any).firebase !== undefined) {\n  logger.warn(`\n    Warning: Firebase is already defined in the global scope. Please make sure\n    Firebase library is only loaded once.\n  `);\n\n  // eslint-disable-next-line\n  const sdkVersion = ((self as any).firebase as FirebaseNamespace).SDK_VERSION;\n  if (sdkVersion && sdkVersion.indexOf('LITE') >= 0) {\n    logger.warn(`\n    Warning: You are trying to load Firebase while using Firebase Performance standalone script.\n    You should load Firebase Performance with this instance of Firebase to avoid loading duplicate code.\n    `);\n  }\n}\n\nconst firebase = firebaseNamespace;\n\nregisterCoreComponents();\n\n// eslint-disable-next-line import/no-default-export\nexport default firebase;\n\nexport { _FirebaseNamespace, _FirebaseService } from './types';\nexport { FirebaseApp, FirebaseNamespace } from './public-types';\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { registerVersion } from '@firebase/app';\n\nimport { name, version } from '../package.json';\n\nexport function registerCoreComponents(variant?: string): void {\n  // Register `app` package.\n  registerVersion(name, version, variant);\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport firebase from '@firebase/app-compat';\nimport { name, version } from '../../package.json';\n\nfirebase.registerVersion(name, version, 'app-compat-cdn');\n\nexport default firebase;\n"],"names":["stringToByteArray","str","out","p","i","length","c","charCodeAt","base64","byteToCharMap_","charToByteMap_","byteToCharMapWebSafe_","charToByteMapWebSafe_","ENCODED_VALS_BASE","ENCODED_VALS","this","ENCODED_VALS_WEBSAFE","HAS_NATIVE_SUPPORT","atob","encodeByteArray","input","webSafe","Array","isArray","Error","init_","byteToCharMap","output","byte1","haveByte2","byte2","haveByte3","byte3","outByte3","outByte4","push","join","encodeString","btoa","decodeString","bytes","pos","c2","c3","c1","String","fromCharCode","u","byteArrayToString","decodeStringToByteArray","charToByteMap","charAt","byte4","base64urlEncodeWithoutPadding","utf8Bytes","replace","deepExtend","target","source","Object","constructor","Date","dateValue","getTime","undefined","prop","hasOwnProperty","Deferred","promise","Promise","resolve","reject","wrapCallback","callback","error","value","catch","FirebaseError","code","message","customData","super","setPrototypeOf","prototype","captureStackTrace","ErrorFactory","create","service","serviceName","errors","data","fullCode","template","PATTERN","_","key","fullMessage","contains","obj","call","deepEqual","a","b","aKeys","keys","bKeys","k","includes","aProp","bProp","isObject","thing","createSubscribe","executor","onNoObservers","proxy","ObserverProxy","subscribe","bind","task","then","e","next","forEachObserver","observer","close","complete","nextOrObserver","methods","method","implementsAnyMethods","noop","unsub","unsubscribeOne","observers","finalized","finalError","observerCount","fn","sendOne","console","err","promisifyRequest","request","errorMessage","onsuccess","event","result","onerror","DBWrapper","_db","objectStoreNames","transaction","storeNames","mode","TransactionWrapper","createObjectStore","storeName","options","ObjectStoreWrapper","_transaction","oncomplete","onabort","objectStore","_store","index","name","IndexWrapper","createIndex","keypath","get","put","delete","clear","_index","Component","instanceFactory","type","setInstantiationMode","instantiationMode","setMultipleInstances","multipleInstances","setServiceProps","props","serviceProps","setInstanceCreatedCallback","onInstanceCreated","DEFAULT_ENTRY_NAME","Provider","container","Map","identifier","normalizedIdentifier","normalizeInstanceIdentifier","instancesDeferred","has","deferred","set","isInitialized","shouldAutoInitialize","instance","getOrInitializeService","instanceIdentifier","getImmediate","optional","getComponent","component","setComponent","instanceDeferred","entries","clearInstance","instancesOptions","instances","services","from","values","all","filter","map","INTERNAL","_delete","isComponentSet","getOptions","initialize","opts","onInit","existingCallbacks","onInitCallbacks","Set","add","existingInstance","invokeOnInitCallbacks","callbacks","ComponentContainer","addComponent","provider","getProvider","addOrOverwriteComponent","providers","getProviders","LogLevel","levelStringToEnum","debug","DEBUG","verbose","VERBOSE","info","INFO","warn","WARN","ERROR","silent","SILENT","defaultLogLevel","ConsoleMethod","defaultLogHandler","logType","args","logLevel","now","toISOString","Logger","_logLevel","val","TypeError","setLogLevel","logHandler","_logHandler","userLogHandler","_userLogHandler","log","PlatformLoggerServiceImpl","getPlatformInfoString","library","version","logString","logger","variant","PLATFORM_LOG_STRING","@firebase/app","@firebase/app-compat","@firebase/analytics","@firebase/analytics-compat","@firebase/app-check","@firebase/app-check-compat","@firebase/auth","@firebase/auth-compat","@firebase/database","@firebase/database-compat","@firebase/functions","@firebase/functions-compat","@firebase/installations","@firebase/installations-compat","@firebase/messaging","@firebase/messaging-compat","@firebase/performance","@firebase/performance-compat","@firebase/remote-config","@firebase/remote-config-compat","@firebase/storage","@firebase/storage-compat","@firebase/firestore","@firebase/firestore-compat","fire-js","firebase","_apps","_components","_addComponent","app","_addOrOverwriteComponent","_registerComponent","componentName","_getProvider","heartbeatController","triggerHeartbeat","ERROR_FACTORY","no-app","bad-app-name","duplicate-app","app-deleted","invalid-app-argument","invalid-log-argument","storage-open","storage-get","storage-set","storage-delete","FirebaseAppImpl","config","_options","_config","_name","_automaticDataCollectionEnabled","automaticDataCollectionEnabled","_container","checkDestroyed","isDeleted","_isDeleted","appName","SDK_VERSION","initializeApp","rawConfig","existingApp","newApp","async","deleteApp","registerVersion","libraryKeyOrName","libraryMismatch","match","versionMismatch","warning","onLog","logCallback","customLogLevel","level","arg","toString","JSON","stringify","ignored","toLowerCase","setUserLogHandler","forEach","inst","DB_NAME","DB_VERSION","STORE_NAME","dbPromise","getDbPromise","dbName","dbVersion","upgradeCallback","db","oldVersion","indexedDB","open","onupgradeneeded","newVersion","originalErrorMessage","writeHeartbeatsToIndexedDB","heartbeatObject","tx","computeKey","appId","HeartbeatServiceImpl","_storage","HeartbeatStorageImpl","_heartbeatsCachePromise","read","_heartbeatsCache","platformLogger","agent","date","getUTCDateString","lastSentHeartbeatDate","heartbeats","some","singleDateHeartbeat","hbTimestamp","valueOf","overwrite","getHeartbeatsHeader","heartbeatsToSend","unsentEntries","heartbeatsCache","maxSize","slice","heartbeatEntry","find","hb","dates","countBytes","pop","extractHeartbeatsForHeader","headerString","today","substring","_canUseIndexedDBPromise","runIndexedDBEnvironmentCheck","preExist","DB_CHECK_NAME","self","deleteDatabase","readHeartbeatsFromIndexedDB","heartbeatsObject","existingHeartbeatsObject","_delegate","removeApp","_getService","_DEFAULT_ENTRY_NAME","_removeServiceInstance","toJSON","createFirebaseNamespaceCore","firebaseAppImpl","apps","namespace","__esModule","modularAPIs.initializeApp","appCompat","modularAPIs.registerVersion","modularAPIs.setLogLevel","modularAPIs.onLog","modularAPIs.SDK_VERSION","registerComponent","componentNameWithoutCompat","serviceNamespace","modularAPIs._registerComponent","appArg","serviceFxn","apply","useAsService","useService","modularAPIs","modularAPIs._DEFAULT_ENTRY_NAME","defineProperty","createFirebaseNamespace","extendNamespace","sdkVersion","indexOf","firebaseNamespace","registerCoreComponents"],"mappings":"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"}