{"version":3,"sources":["../../../src/platformLoggerService.ts","../../../src/logger.ts","../../../src/constants.ts","../../../src/internal.ts","../../../src/errors.ts","../../../src/firebaseApp.ts","../../../src/api.ts","../../../src/indexeddb.ts","../../../src/heartbeatService.ts","../../../src/registerCoreComponents.ts","../../../src/index.ts","../../../src/component.ts","../../../src/provider.ts","../../../src/component_container.ts","../../src/constants.ts","../../src/assert.ts","../../src/crypt.ts","../../src/deepCopy.ts","../../src/deferred.ts","../../src/emulator.ts","../../src/environment.ts","../../src/errors.ts","../../src/json.ts","../../src/jwt.ts","../../src/obj.ts","../../src/query.ts","../../src/sha1.ts","../../src/subscribe.ts","../../src/validation.ts","../../src/utf8.ts","../../src/exponential_backoff.ts","../../src/formatters.ts","../../src/compat.ts"],"names":["appName","appCompatName","analyticsName","analyticsCompatName","appCheckName","appCheckCompatName","authName","authCompatName","databaseName","databaseCompatName","functionsName","functionsCompatName","installationsName","installationsCompatName","messagingName","messagingCompatName","performanceName","performanceCompatName","remoteConfigName","remoteConfigCompatName","storageName","storageCompatName","firestoreName","firestoreCompatName","packageName","setLogLevelImpl","name","version","stringToByteArray"],"mappings":"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","file":"static/js/vendors~main~c6e4a0df.e07dc596.chunk.js","sourcesContent":["/**\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 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\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 { 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 { DBSchema, openDB, IDBPDatabase } from 'idb';\nimport { AppError, ERROR_FACTORY } from './errors';\nimport { FirebaseApp } from './public-types';\nimport { HeartbeatsInIndexedDB } from './types';\n\nconst DB_NAME = 'firebase-heartbeat-database';\nconst DB_VERSION = 1;\nconst STORE_NAME = 'firebase-heartbeat-store';\n\ninterface AppDB extends DBSchema {\n  'firebase-heartbeat-store': {\n    key: string;\n    value: HeartbeatsInIndexedDB;\n  };\n}\n\nlet dbPromise: Promise<IDBPDatabase<AppDB>> | null = null;\nfunction getDbPromise(): Promise<IDBPDatabase<AppDB>> {\n  if (!dbPromise) {\n    dbPromise = openDB<AppDB>(DB_NAME, DB_VERSION, {\n      upgrade: (db, oldVersion) => {\n        // We don't use 'break' in this switch statement, the fall-through\n        // behavior is what we want, because if there are multiple versions between\n        // the old version and the current version, we want ALL the migrations\n        // that correspond to those versions to run, not only the last one.\n        // eslint-disable-next-line default-case\n        switch (oldVersion) {\n          case 0:\n            db.createObjectStore(STORE_NAME);\n        }\n      }\n    }).catch(e => {\n      throw ERROR_FACTORY.create(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 as Error)?.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.done;\n  } catch (e) {\n    throw ERROR_FACTORY.create(AppError.STORAGE_WRITE, {\n      originalErrorMessage: (e as Error)?.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 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 * 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 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\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\n/**\n * @fileoverview Firebase constants.  Some of these (@defines) can be overridden at compile-time.\n */\n\nexport const CONSTANTS = {\n  /**\n   * @define {boolean} Whether this is the client Node.js SDK.\n   */\n  NODE_CLIENT: false,\n  /**\n   * @define {boolean} Whether this is the Admin Node.js SDK.\n   */\n  NODE_ADMIN: false,\n\n  /**\n   * Firebase SDK Version\n   */\n  SDK_VERSION: '${JSCORE_VERSION}'\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 * Throws an error if the provided assertion is falsy\n */\nexport const assert = function (assertion: unknown, message: string): void {\n  if (!assertion) {\n    throw assertionError(message);\n  }\n};\n\n/**\n * Returns an Error object suitable for throwing.\n */\nexport const assertionError = function (message: string): Error {\n  return new Error(\n    'Firebase Database (' +\n      CONSTANTS.SDK_VERSION +\n      ') INTERNAL ASSERT FAILED: ' +\n      message\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\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 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 { base64urlEncodeWithoutPadding } from './crypt';\n\n// Firebase Auth tokens contain snake_case claims following the JWT standard / convention.\n/* eslint-disable camelcase */\n\nexport type FirebaseSignInProvider =\n  | 'custom'\n  | 'email'\n  | 'password'\n  | 'phone'\n  | 'anonymous'\n  | 'google.com'\n  | 'facebook.com'\n  | 'github.com'\n  | 'twitter.com'\n  | 'microsoft.com'\n  | 'apple.com';\n\ninterface FirebaseIdToken {\n  // Always set to https://securetoken.google.com/PROJECT_ID\n  iss: string;\n\n  // Always set to PROJECT_ID\n  aud: string;\n\n  // The user's unique ID\n  sub: string;\n\n  // The token issue time, in seconds since epoch\n  iat: number;\n\n  // The token expiry time, normally 'iat' + 3600\n  exp: number;\n\n  // The user's unique ID. Must be equal to 'sub'\n  user_id: string;\n\n  // The time the user authenticated, normally 'iat'\n  auth_time: number;\n\n  // The sign in provider, only set when the provider is 'anonymous'\n  provider_id?: 'anonymous';\n\n  // The user's primary email\n  email?: string;\n\n  // The user's email verification status\n  email_verified?: boolean;\n\n  // The user's primary phone number\n  phone_number?: string;\n\n  // The user's display name\n  name?: string;\n\n  // The user's profile photo URL\n  picture?: string;\n\n  // Information on all identities linked to this user\n  firebase: {\n    // The primary sign-in provider\n    sign_in_provider: FirebaseSignInProvider;\n\n    // A map of providers to the user's list of unique identifiers from\n    // each provider\n    identities?: { [provider in FirebaseSignInProvider]?: string[] };\n  };\n\n  // Custom claims set by the developer\n  [claim: string]: unknown;\n\n  uid?: never; // Try to catch a common mistake of \"uid\" (should be \"sub\" instead).\n}\n\nexport type EmulatorMockTokenOptions = ({ user_id: string } | { sub: string }) &\n  Partial<FirebaseIdToken>;\n\nexport function createMockUserToken(\n  token: EmulatorMockTokenOptions,\n  projectId?: string\n): string {\n  if (token.uid) {\n    throw new Error(\n      'The \"uid\" field is no longer supported by mockUserToken. Please use \"sub\" instead for Firebase Auth User ID.'\n    );\n  }\n  // Unsecured JWTs use \"none\" as the algorithm.\n  const header = {\n    alg: 'none',\n    type: 'JWT'\n  };\n\n  const project = projectId || 'demo-project';\n  const iat = token.iat || 0;\n  const sub = token.sub || token.user_id;\n  if (!sub) {\n    throw new Error(\"mockUserToken must contain 'sub' or 'user_id' field!\");\n  }\n\n  const payload: FirebaseIdToken = {\n    // Set all required fields to decent defaults\n    iss: `https://securetoken.google.com/${project}`,\n    aud: project,\n    iat,\n    exp: iat + 3600,\n    auth_time: iat,\n    sub,\n    user_id: sub,\n    firebase: {\n      sign_in_provider: 'custom',\n      identities: {}\n    },\n\n    // Override with user options\n    ...token\n  };\n\n  // Unsecured JWTs use the empty string as a signature.\n  const signature = '';\n  return [\n    base64urlEncodeWithoutPadding(JSON.stringify(header)),\n    base64urlEncodeWithoutPadding(JSON.stringify(payload)),\n    signature\n  ].join('.');\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 * @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\n/**\n * Evaluates a JSON string into a javascript object.\n *\n * @param {string} str A string containing JSON.\n * @return {*} The javascript object representing the specified JSON.\n */\nexport function jsonEval(str: string): unknown {\n  return JSON.parse(str);\n}\n\n/**\n * Returns JSON representing a javascript object.\n * @param {*} data Javascript object to be stringified.\n * @return {string} The JSON contents of the object.\n */\nexport function stringify(data: unknown): string {\n  return JSON.stringify(data);\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 { base64Decode } from './crypt';\nimport { jsonEval } from './json';\n\ninterface Claims {\n  [key: string]: {};\n}\n\ninterface DecodedToken {\n  header: object;\n  claims: Claims;\n  data: object;\n  signature: string;\n}\n\n/**\n * Decodes a Firebase auth. token into constituent parts.\n *\n * Notes:\n * - May return with invalid / incomplete claims if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const decode = function (token: string): DecodedToken {\n  let header = {},\n    claims: Claims = {},\n    data = {},\n    signature = '';\n\n  try {\n    const parts = token.split('.');\n    header = jsonEval(base64Decode(parts[0]) || '') as object;\n    claims = jsonEval(base64Decode(parts[1]) || '') as Claims;\n    signature = parts[2];\n    data = claims['d'] || {};\n    delete claims['d'];\n  } catch (e) {}\n\n  return {\n    header,\n    claims,\n    data,\n    signature\n  };\n};\n\ninterface DecodedToken {\n  header: object;\n  claims: Claims;\n  data: object;\n  signature: string;\n}\n\n/**\n * Decodes a Firebase auth. token and checks the validity of its time-based claims. Will return true if the\n * token is within the time window authorized by the 'nbf' (not-before) and 'iat' (issued-at) claims.\n *\n * Notes:\n * - May return a false negative if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const isValidTimestamp = function (token: string): boolean {\n  const claims: Claims = decode(token).claims;\n  const now: number = Math.floor(new Date().getTime() / 1000);\n  let validSince: number = 0,\n    validUntil: number = 0;\n\n  if (typeof claims === 'object') {\n    if (claims.hasOwnProperty('nbf')) {\n      validSince = claims['nbf'] as number;\n    } else if (claims.hasOwnProperty('iat')) {\n      validSince = claims['iat'] as number;\n    }\n\n    if (claims.hasOwnProperty('exp')) {\n      validUntil = claims['exp'] as number;\n    } else {\n      // token will expire after 24h by default\n      validUntil = validSince + 86400;\n    }\n  }\n\n  return (\n    !!now &&\n    !!validSince &&\n    !!validUntil &&\n    now >= validSince &&\n    now <= validUntil\n  );\n};\n\n/**\n * Decodes a Firebase auth. token and returns its issued at time if valid, null otherwise.\n *\n * Notes:\n * - May return null if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const issuedAtTime = function (token: string): number | null {\n  const claims: Claims = decode(token).claims;\n  if (typeof claims === 'object' && claims.hasOwnProperty('iat')) {\n    return claims['iat'] as number;\n  }\n  return null;\n};\n\n/**\n * Decodes a Firebase auth. token and checks the validity of its format. Expects a valid issued-at time.\n *\n * Notes:\n * - May return a false negative if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const isValidFormat = function (token: string): boolean {\n  const decoded = decode(token),\n    claims = decoded.claims;\n\n  return !!claims && typeof claims === 'object' && claims.hasOwnProperty('iat');\n};\n\n/**\n * Attempts to peer into an auth token and determine if it's an admin auth token by looking at the claims portion.\n *\n * Notes:\n * - May return a false negative if there's no native base64 decoding support.\n * - Doesn't check if the token is actually valid.\n */\nexport const isAdmin = function (token: string): boolean {\n  const claims: Claims = decode(token).claims;\n  return typeof claims === 'object' && claims['admin'] === true;\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 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 */\n\n/**\n * Returns a querystring-formatted string (e.g. &arg=val&arg2=val2) from a\n * params object (e.g. {arg: 'val', arg2: 'val2'})\n * Note: You must prepend it with ? when adding it to a URL.\n */\nexport function querystring(querystringParams: {\n  [key: string]: string | number;\n}): string {\n  const params = [];\n  for (const [key, value] of Object.entries(querystringParams)) {\n    if (Array.isArray(value)) {\n      value.forEach(arrayVal => {\n        params.push(\n          encodeURIComponent(key) + '=' + encodeURIComponent(arrayVal)\n        );\n      });\n    } else {\n      params.push(encodeURIComponent(key) + '=' + encodeURIComponent(value));\n    }\n  }\n  return params.length ? '&' + params.join('&') : '';\n}\n\n/**\n * Decodes a querystring (e.g. ?arg=val&arg2=val2) into a params object\n * (e.g. {arg: 'val', arg2: 'val2'})\n */\nexport function querystringDecode(querystring: string): Record<string, string> {\n  const obj: Record<string, string> = {};\n  const tokens = querystring.replace(/^\\?/, '').split('&');\n\n  tokens.forEach(token => {\n    if (token) {\n      const [key, value] = token.split('=');\n      obj[decodeURIComponent(key)] = decodeURIComponent(value);\n    }\n  });\n  return obj;\n}\n\n/**\n * Extract the query string part of a URL, including the leading question mark (if present).\n */\nexport function extractQuerystring(url: string): string {\n  const queryStart = url.indexOf('?');\n  if (!queryStart) {\n    return '';\n  }\n  const fragmentStart = url.indexOf('#', queryStart);\n  return url.substring(\n    queryStart,\n    fragmentStart > 0 ? fragmentStart : undefined\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/**\n * @fileoverview SHA-1 cryptographic hash.\n * Variable names follow the notation in FIPS PUB 180-3:\n * http://csrc.nist.gov/publications/fips/fips180-3/fips180-3_final.pdf.\n *\n * Usage:\n *   var sha1 = new sha1();\n *   sha1.update(bytes);\n *   var hash = sha1.digest();\n *\n * Performance:\n *   Chrome 23:   ~400 Mbit/s\n *   Firefox 16:  ~250 Mbit/s\n *\n */\n\n/**\n * SHA-1 cryptographic hash constructor.\n *\n * The properties declared here are discussed in the above algorithm document.\n * @constructor\n * @final\n * @struct\n */\nexport class Sha1 {\n  /**\n   * Holds the previous values of accumulated variables a-e in the compress_\n   * function.\n   * @private\n   */\n  private chain_: number[] = [];\n\n  /**\n   * A buffer holding the partially computed hash result.\n   * @private\n   */\n  private buf_: number[] = [];\n\n  /**\n   * An array of 80 bytes, each a part of the message to be hashed.  Referred to\n   * as the message schedule in the docs.\n   * @private\n   */\n  private W_: number[] = [];\n\n  /**\n   * Contains data needed to pad messages less than 64 bytes.\n   * @private\n   */\n  private pad_: number[] = [];\n\n  /**\n   * @private {number}\n   */\n  private inbuf_: number = 0;\n\n  /**\n   * @private {number}\n   */\n  private total_: number = 0;\n\n  blockSize: number;\n\n  constructor() {\n    this.blockSize = 512 / 8;\n\n    this.pad_[0] = 128;\n    for (let i = 1; i < this.blockSize; ++i) {\n      this.pad_[i] = 0;\n    }\n\n    this.reset();\n  }\n\n  reset(): void {\n    this.chain_[0] = 0x67452301;\n    this.chain_[1] = 0xefcdab89;\n    this.chain_[2] = 0x98badcfe;\n    this.chain_[3] = 0x10325476;\n    this.chain_[4] = 0xc3d2e1f0;\n\n    this.inbuf_ = 0;\n    this.total_ = 0;\n  }\n\n  /**\n   * Internal compress helper function.\n   * @param buf Block to compress.\n   * @param offset Offset of the block in the buffer.\n   * @private\n   */\n  compress_(buf: number[] | Uint8Array | string, offset?: number): void {\n    if (!offset) {\n      offset = 0;\n    }\n\n    const W = this.W_;\n\n    // get 16 big endian words\n    if (typeof buf === 'string') {\n      for (let i = 0; i < 16; i++) {\n        // TODO(user): [bug 8140122] Recent versions of Safari for Mac OS and iOS\n        // have a bug that turns the post-increment ++ operator into pre-increment\n        // during JIT compilation.  We have code that depends heavily on SHA-1 for\n        // correctness and which is affected by this bug, so I've removed all uses\n        // of post-increment ++ in which the result value is used.  We can revert\n        // this change once the Safari bug\n        // (https://bugs.webkit.org/show_bug.cgi?id=109036) has been fixed and\n        // most clients have been updated.\n        W[i] =\n          (buf.charCodeAt(offset) << 24) |\n          (buf.charCodeAt(offset + 1) << 16) |\n          (buf.charCodeAt(offset + 2) << 8) |\n          buf.charCodeAt(offset + 3);\n        offset += 4;\n      }\n    } else {\n      for (let i = 0; i < 16; i++) {\n        W[i] =\n          (buf[offset] << 24) |\n          (buf[offset + 1] << 16) |\n          (buf[offset + 2] << 8) |\n          buf[offset + 3];\n        offset += 4;\n      }\n    }\n\n    // expand to 80 words\n    for (let i = 16; i < 80; i++) {\n      const t = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];\n      W[i] = ((t << 1) | (t >>> 31)) & 0xffffffff;\n    }\n\n    let a = this.chain_[0];\n    let b = this.chain_[1];\n    let c = this.chain_[2];\n    let d = this.chain_[3];\n    let e = this.chain_[4];\n    let f, k;\n\n    // TODO(user): Try to unroll this loop to speed up the computation.\n    for (let i = 0; i < 80; i++) {\n      if (i < 40) {\n        if (i < 20) {\n          f = d ^ (b & (c ^ d));\n          k = 0x5a827999;\n        } else {\n          f = b ^ c ^ d;\n          k = 0x6ed9eba1;\n        }\n      } else {\n        if (i < 60) {\n          f = (b & c) | (d & (b | c));\n          k = 0x8f1bbcdc;\n        } else {\n          f = b ^ c ^ d;\n          k = 0xca62c1d6;\n        }\n      }\n\n      const t = (((a << 5) | (a >>> 27)) + f + e + k + W[i]) & 0xffffffff;\n      e = d;\n      d = c;\n      c = ((b << 30) | (b >>> 2)) & 0xffffffff;\n      b = a;\n      a = t;\n    }\n\n    this.chain_[0] = (this.chain_[0] + a) & 0xffffffff;\n    this.chain_[1] = (this.chain_[1] + b) & 0xffffffff;\n    this.chain_[2] = (this.chain_[2] + c) & 0xffffffff;\n    this.chain_[3] = (this.chain_[3] + d) & 0xffffffff;\n    this.chain_[4] = (this.chain_[4] + e) & 0xffffffff;\n  }\n\n  update(bytes?: number[] | Uint8Array | string, length?: number): void {\n    // TODO(johnlenz): tighten the function signature and remove this check\n    if (bytes == null) {\n      return;\n    }\n\n    if (length === undefined) {\n      length = bytes.length;\n    }\n\n    const lengthMinusBlock = length - this.blockSize;\n    let n = 0;\n    // Using local instead of member variables gives ~5% speedup on Firefox 16.\n    const buf = this.buf_;\n    let inbuf = this.inbuf_;\n\n    // The outer while loop should execute at most twice.\n    while (n < length) {\n      // When we have no data in the block to top up, we can directly process the\n      // input buffer (assuming it contains sufficient data). This gives ~25%\n      // speedup on Chrome 23 and ~15% speedup on Firefox 16, but requires that\n      // the data is provided in large chunks (or in multiples of 64 bytes).\n      if (inbuf === 0) {\n        while (n <= lengthMinusBlock) {\n          this.compress_(bytes, n);\n          n += this.blockSize;\n        }\n      }\n\n      if (typeof bytes === 'string') {\n        while (n < length) {\n          buf[inbuf] = bytes.charCodeAt(n);\n          ++inbuf;\n          ++n;\n          if (inbuf === this.blockSize) {\n            this.compress_(buf);\n            inbuf = 0;\n            // Jump to the outer loop so we use the full-block optimization.\n            break;\n          }\n        }\n      } else {\n        while (n < length) {\n          buf[inbuf] = bytes[n];\n          ++inbuf;\n          ++n;\n          if (inbuf === this.blockSize) {\n            this.compress_(buf);\n            inbuf = 0;\n            // Jump to the outer loop so we use the full-block optimization.\n            break;\n          }\n        }\n      }\n    }\n\n    this.inbuf_ = inbuf;\n    this.total_ += length;\n  }\n\n  /** @override */\n  digest(): number[] {\n    const digest: number[] = [];\n    let totalBits = this.total_ * 8;\n\n    // Add pad 0x80 0x00*.\n    if (this.inbuf_ < 56) {\n      this.update(this.pad_, 56 - this.inbuf_);\n    } else {\n      this.update(this.pad_, this.blockSize - (this.inbuf_ - 56));\n    }\n\n    // Add # bits.\n    for (let i = this.blockSize - 1; i >= 56; i--) {\n      this.buf_[i] = totalBits & 255;\n      totalBits /= 256; // Don't use bit-shifting here!\n    }\n\n    this.compress_(this.buf_);\n\n    let n = 0;\n    for (let i = 0; i < 5; i++) {\n      for (let j = 24; j >= 0; j -= 8) {\n        digest[n] = (this.chain_[i] >> j) & 255;\n        ++n;\n      }\n    }\n    return digest;\n  }\n}\n","/**\n * @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 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 * Check to make sure the appropriate number of arguments are provided for a public function.\n * Throws an error if it fails.\n *\n * @param fnName The function name\n * @param minCount The minimum number of arguments to allow for the function call\n * @param maxCount The maximum number of argument to allow for the function call\n * @param argCount The actual number of arguments provided.\n */\nexport const validateArgCount = function (\n  fnName: string,\n  minCount: number,\n  maxCount: number,\n  argCount: number\n): void {\n  let argError;\n  if (argCount < minCount) {\n    argError = 'at least ' + minCount;\n  } else if (argCount > maxCount) {\n    argError = maxCount === 0 ? 'none' : 'no more than ' + maxCount;\n  }\n  if (argError) {\n    const error =\n      fnName +\n      ' failed: Was called with ' +\n      argCount +\n      (argCount === 1 ? ' argument.' : ' arguments.') +\n      ' Expects ' +\n      argError +\n      '.';\n    throw new Error(error);\n  }\n};\n\n/**\n * Generates a string to prefix an error message about failed argument validation\n *\n * @param fnName The function name\n * @param argName The name of the argument\n * @return The prefix to add to the error thrown for validation.\n */\nexport function errorPrefix(fnName: string, argName: string): string {\n  return `${fnName} failed: ${argName} argument `;\n}\n\n/**\n * @param fnName\n * @param argumentNumber\n * @param namespace\n * @param optional\n */\nexport function validateNamespace(\n  fnName: string,\n  namespace: string,\n  optional: boolean\n): void {\n  if (optional && !namespace) {\n    return;\n  }\n  if (typeof namespace !== 'string') {\n    //TODO: I should do more validation here. We only allow certain chars in namespaces.\n    throw new Error(\n      errorPrefix(fnName, 'namespace') + 'must be a valid firebase namespace.'\n    );\n  }\n}\n\nexport function validateCallback(\n  fnName: string,\n  argumentName: string,\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  callback: Function,\n  optional: boolean\n): void {\n  if (optional && !callback) {\n    return;\n  }\n  if (typeof callback !== 'function') {\n    throw new Error(\n      errorPrefix(fnName, argumentName) + 'must be a valid function.'\n    );\n  }\n}\n\nexport function validateContextObject(\n  fnName: string,\n  argumentName: string,\n  context: unknown,\n  optional: boolean\n): void {\n  if (optional && !context) {\n    return;\n  }\n  if (typeof context !== 'object' || context === null) {\n    throw new Error(\n      errorPrefix(fnName, argumentName) + 'must be a valid context object.'\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\nimport { assert } from './assert';\n\n// Code originally came from goog.crypt.stringToUtf8ByteArray, but for some reason they\n// automatically replaced '\\r\\n' with '\\n', and they didn't handle surrogate pairs,\n// so it's been modified.\n\n// Note that not all Unicode characters appear as single characters in JavaScript strings.\n// fromCharCode returns the UTF-16 encoding of a character - so some Unicode characters\n// use 2 characters in Javascript.  All 4-byte UTF-8 characters begin with a first\n// character in the range 0xD800 - 0xDBFF (the first character of a so-called surrogate\n// pair).\n// See http://www.ecma-international.org/ecma-262/5.1/#sec-15.1.3\n\n/**\n * @param {string} str\n * @return {Array}\n */\nexport const stringToByteArray = function (str: string): number[] {\n  const out: number[] = [];\n  let p = 0;\n  for (let i = 0; i < str.length; i++) {\n    let c = str.charCodeAt(i);\n\n    // Is this the lead surrogate in a surrogate pair?\n    if (c >= 0xd800 && c <= 0xdbff) {\n      const high = c - 0xd800; // the high 10 bits.\n      i++;\n      assert(i < str.length, 'Surrogate pair missing trail surrogate.');\n      const low = str.charCodeAt(i) - 0xdc00; // the low 10 bits.\n      c = 0x10000 + (high << 10) + low;\n    }\n\n    if (c < 128) {\n      out[p++] = c;\n    } else if (c < 2048) {\n      out[p++] = (c >> 6) | 192;\n      out[p++] = (c & 63) | 128;\n    } else if (c < 65536) {\n      out[p++] = (c >> 12) | 224;\n      out[p++] = ((c >> 6) & 63) | 128;\n      out[p++] = (c & 63) | 128;\n    } else {\n      out[p++] = (c >> 18) | 240;\n      out[p++] = ((c >> 12) & 63) | 128;\n      out[p++] = ((c >> 6) & 63) | 128;\n      out[p++] = (c & 63) | 128;\n    }\n  }\n  return out;\n};\n\n/**\n * Calculate length without actually converting; useful for doing cheaper validation.\n * @param {string} str\n * @return {number}\n */\nexport const stringLength = function (str: string): number {\n  let p = 0;\n  for (let i = 0; i < str.length; i++) {\n    const c = str.charCodeAt(i);\n    if (c < 128) {\n      p++;\n    } else if (c < 2048) {\n      p += 2;\n    } else if (c >= 0xd800 && c <= 0xdbff) {\n      // Lead surrogate of a surrogate pair.  The pair together will take 4 bytes to represent.\n      p += 4;\n      i++; // skip trail surrogate.\n    } else {\n      p += 3;\n    }\n  }\n  return p;\n};\n","/**\n * @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\n/**\n * The amount of milliseconds to exponentially increase.\n */\nconst DEFAULT_INTERVAL_MILLIS = 1000;\n\n/**\n * The factor to backoff by.\n * Should be a number greater than 1.\n */\nconst DEFAULT_BACKOFF_FACTOR = 2;\n\n/**\n * The maximum milliseconds to increase to.\n *\n * <p>Visible for testing\n */\nexport const MAX_VALUE_MILLIS = 4 * 60 * 60 * 1000; // Four hours, like iOS and Android.\n\n/**\n * The percentage of backoff time to randomize by.\n * See\n * http://go/safe-client-behavior#step-1-determine-the-appropriate-retry-interval-to-handle-spike-traffic\n * for context.\n *\n * <p>Visible for testing\n */\nexport const RANDOM_FACTOR = 0.5;\n\n/**\n * Based on the backoff method from\n * https://github.com/google/closure-library/blob/master/closure/goog/math/exponentialbackoff.js.\n * Extracted here so we don't need to pass metadata and a stateful ExponentialBackoff object around.\n */\nexport function calculateBackoffMillis(\n  backoffCount: number,\n  intervalMillis: number = DEFAULT_INTERVAL_MILLIS,\n  backoffFactor: number = DEFAULT_BACKOFF_FACTOR\n): number {\n  // Calculates an exponentially increasing value.\n  // Deviation: calculates value from count and a constant interval, so we only need to save value\n  // and count to restore state.\n  const currBaseValue = intervalMillis * Math.pow(backoffFactor, backoffCount);\n\n  // A random \"fuzz\" to avoid waves of retries.\n  // Deviation: randomFactor is required.\n  const randomWait = Math.round(\n    // A fraction of the backoff value to add/subtract.\n    // Deviation: changes multiplication order to improve readability.\n    RANDOM_FACTOR *\n      currBaseValue *\n      // A random float (rounded to int by Math.round above) in the range [-1, 1]. Determines\n      // if we add or subtract.\n      (Math.random() - 0.5) *\n      2\n  );\n\n  // Limits backoff to max to avoid effectively permanent backoff.\n  return Math.min(MAX_VALUE_MILLIS, currBaseValue + randomWait);\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\n/**\n * Provide English ordinal letters after a number\n */\nexport function ordinal(i: number): string {\n  if (!Number.isFinite(i)) {\n    return `${i}`;\n  }\n  return i + indicator(i);\n}\n\nfunction indicator(i: number): string {\n  i = Math.abs(i);\n  const cent = i % 100;\n  if (cent >= 10 && cent <= 20) {\n    return 'th';\n  }\n  const dec = i % 10;\n  if (dec === 1) {\n    return 'st';\n  }\n  if (dec === 2) {\n    return 'nd';\n  }\n  if (dec === 3) {\n    return 'rd';\n  }\n  return 'th';\n}\n","/**\n * @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\nexport interface Compat<T> {\n  _delegate: T;\n}\n\nexport function getModularInstance<ExpService>(\n  service: Compat<ExpService> | ExpService\n): ExpService {\n  if (service && (service as Compat<ExpService>)._delegate) {\n    return (service as Compat<ExpService>)._delegate;\n  } else {\n    return service as ExpService;\n  }\n}\n"],"sourceRoot":""}