text: import { Component, ComponentContainer } from '@firebase/component';
  import { Logger, setUserLogHandler, setLogLevel as setLogLevel$1 } from '@firebase/logger';
  import { ErrorFactory, deepEqual } from '@firebase/util';
  export { FirebaseError } from '@firebase/util';
  
  /**
   * @license
   * Copyright 2019 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  class PlatformLoggerServiceImpl {
      constructor(container) {
          this.container = container;
      }
      // In initial implementation, this will be called by installations on
      // auth token refresh, and installations will send this string.
      getPlatformInfoString() {
          const providers = this.container.getProviders();
          // Loop through providers and get library/version pairs from any that are
          // version components.
          return providers
              .map(provider => {
              if (isVersionServiceProvider(provider)) {
                  const service = provider.getImmediate();
                  return `${service.library}/${service.version}`;
              }
              else {
                  return null;
              }
          })
              .filter(logString => logString)
              .join(' ');
      }
  }
  /**
   *
   * @param provider check if this provider provides a VersionService
   *
   * NOTE: Using Provider<'app-version'> is a hack to indicate that the provider
   * provides VersionService. The provider is not necessarily a 'app-version'
   * provider.
   */
  function isVersionServiceProvider(provider) {
      const component = provider.getComponent();
      return (component === null || component === void 0 ? void 0 : component.type) === "VERSION" /* VERSION */;
  }
  
  const name$o = "@firebase/app";
  const version$1 = "0.7.1";
  
  /**
   * @license
   * Copyright 2019 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  const logger = new Logger('@firebase/app');
  
  const name$n = "@firebase/app-compat";
  
  const name$m = "@firebase/analytics-compat";
  
  const name$l = "@firebase/analytics";
  
  const name$k = "@firebase/app-check-compat";
  
  const name$j = "@firebase/app-check";
  
  const name$i = "@firebase/auth";
  
  const name$h = "@firebase/auth-compat";
  
  const name$g = "@firebase/database";
  
  const name$f = "@firebase/database-compat";
  
  const name$e = "@firebase/functions";
  
  const name$d = "@firebase/functions-compat";
  
  const name$c = "@firebase/installations";
  
  const name$b = "@firebase/installations-compat";
  
  const name$a = "@firebase/messaging";
  
  const name$9 = "@firebase/messaging-compat";
  
  const name$8 = "@firebase/performance";
  
  const name$7 = "@firebase/performance-compat";
  
  const name$6 = "@firebase/remote-config";
  
  const name$5 = "@firebase/remote-config-compat";
  
  const name$4 = "@firebase/storage";
  
  const name$3 = "@firebase/storage-compat";
  
  const name$2 = "@firebase/firestore";
  
  const name$1 = "@firebase/firestore-compat";
  
  const name = "firebase";
  const version = "9.1.0";
  
  /**
   * @license
   * Copyright 2019 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * The default app name
   *
   * @internal
   */
  const DEFAULT_ENTRY_NAME = '[DEFAULT]';
  const PLATFORM_LOG_STRING = {
      [name$o]: 'fire-core',
      [name$n]: 'fire-core-compat',
      [name$l]: 'fire-analytics',
      [name$m]: 'fire-analytics-compat',
      [name$j]: 'fire-app-check',
      [name$k]: 'fire-app-check-compat',
      [name$i]: 'fire-auth',
      [name$h]: 'fire-auth-compat',
      [name$g]: 'fire-rtdb',
      [name$f]: 'fire-rtdb-compat',
      [name$e]: 'fire-fn',
      [name$d]: 'fire-fn-compat',
      [name$c]: 'fire-iid',
      [name$b]: 'fire-iid-compat',
      [name$a]: 'fire-fcm',
      [name$9]: 'fire-fcm-compat',
      [name$8]: 'fire-perf',
      [name$7]: 'fire-perf-compat',
      [name$6]: 'fire-rc',
      [name$5]: 'fire-rc-compat',
      [name$4]: 'fire-gcs',
      [name$3]: 'fire-gcs-compat',
      [name$2]: 'fire-fst',
      [name$1]: 'fire-fst-compat',
      'fire-js': 'fire-js',
      [name]: 'fire-js-all'
  };
  
  /**
   * @license
   * Copyright 2019 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * @internal
   */
  const _apps = new Map();
  /**
   * Registered components.
   *
   * @internal
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  const _components = new Map();
  /**
   * @param component - the component being added to this app's container
   *
   * @internal
   */
  function _addComponent(app, component) {
      try {
          app.container.addComponent(component);
      }
      catch (e) {
          logger.debug(`Component ${component.name} failed to register with FirebaseApp ${app.name}`, e);
      }
  }
  /**
   *
   * @internal
   */
  function _addOrOverwriteComponent(app, component) {
      app.container.addOrOverwriteComponent(component);
  }
  /**
   *
   * @param component - the component to register
   * @returns whether or not the component is registered successfully
   *
   * @internal
   */
  function _registerComponent(component) {
      const componentName = component.name;
      if (_components.has(componentName)) {
          logger.debug(`There were multiple attempts to register component ${componentName}.`);
          return false;
      }
      _components.set(componentName, component);
      // add the component to existing app instances
      for (const app of _apps.values()) {
          _addComponent(app, component);
      }
      return true;
  }
  /**
   *
   * @param app - FirebaseApp instance
   * @param name - service name
   *
   * @returns the provider for the service with the matching name
   *
   * @internal
   */
  function _getProvider(app, name) {
      return app.container.getProvider(name);
  }
  /**
   *
   * @param app - FirebaseApp instance
   * @param name - service name
   * @param instanceIdentifier - service instance identifier in case the service supports multiple instances
   *
   * @internal
   */
  function _removeServiceInstance(app, name, instanceIdentifier = DEFAULT_ENTRY_NAME) {
      _getProvider(app, name).clearInstance(instanceIdentifier);
  }
  /**
   * Test only
   *
   * @internal
   */
  function _clearComponents() {
      _components.clear();
  }
  
  /**
   * @license
   * Copyright 2019 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  const ERRORS = {
      ["no-app" /* NO_APP */]: "No Firebase App '{$appName}' has been created - " +
          'call Firebase App.initializeApp()',
      ["bad-app-name" /* BAD_APP_NAME */]: "Illegal App name: '{$appName}",
      ["duplicate-app" /* DUPLICATE_APP */]: "Firebase App named '{$appName}' already exists with different options or config",
      ["app-deleted" /* APP_DELETED */]: "Firebase App named '{$appName}' already deleted",
      ["invalid-app-argument" /* INVALID_APP_ARGUMENT */]: 'firebase.{$appName}() takes either no argument or a ' +
          'Firebase App instance.',
      ["invalid-log-argument" /* INVALID_LOG_ARGUMENT */]: 'First argument to `onLog` must be null or a function.'
  };
  const ERROR_FACTORY = new ErrorFactory('app', 'Firebase', ERRORS);
  
  /**
   * @license
   * Copyright 2019 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  class FirebaseAppImpl {
      constructor(options, config, container) {
          this._isDeleted = false;
          this._options = Object.assign({}, options);
          this._config = Object.assign({}, config);
          this._name = config.name;
          this._automaticDataCollectionEnabled =
              config.automaticDataCollectionEnabled;
          this._container = container;
          this.container.addComponent(new Component('app', () => this, "PUBLIC" /* PUBLIC */));
      }
      get automaticDataCollectionEnabled() {
          this.checkDestroyed();
          return this._automaticDataCollectionEnabled;
      }
      set automaticDataCollectionEnabled(val) {
          this.checkDestroyed();
          this._automaticDataCollectionEnabled = val;
      }
      get name() {
          this.checkDestroyed();
          return this._name;
      }
      get options() {
          this.checkDestroyed();
          return this._options;
      }
      get config() {
          this.checkDestroyed();
          return this._config;
      }
      get container() {
          return this._container;
      }
      get isDeleted() {
          return this._isDeleted;
      }
      set isDeleted(val) {
          this._isDeleted = val;
      }
      /**
       * This function will throw an Error if the App has already been deleted -
       * use before performing API actions on the App.
       */
      checkDestroyed() {
          if (this.isDeleted) {
              throw ERROR_FACTORY.create("app-deleted" /* APP_DELETED */, { appName: this._name });
          }
      }
  }
  
  /**
   * @license
   * Copyright 2019 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  /**
   * The current SDK version.
   *
   * @public
   */
  const SDK_VERSION = version;
  function initializeApp(options, rawConfig = {}) {
      if (typeof rawConfig !== 'object') {
          const name = rawConfig;
          rawConfig = { name };
      }
      const config = Object.assign({ name: DEFAULT_ENTRY_NAME, automaticDataCollectionEnabled: false }, rawConfig);
      const name = config.name;
      if (typeof name !== 'string' || !name) {
          throw ERROR_FACTORY.create("bad-app-name" /* BAD_APP_NAME */, {
              appName: String(name)
          });
      }
      const existingApp = _apps.get(name);
      if (existingApp) {
          // return the existing app if options and config deep equal the ones in the existing app.
          if (deepEqual(options, existingApp.options) &&
              deepEqual(config, existingApp.config)) {
              return existingApp;
          }
          else {
              throw ERROR_FACTORY.create("duplicate-app" /* DUPLICATE_APP */, { appName: name });
          }
      }
      const container = new ComponentContainer(name);
      for (const component of _components.values()) {
          container.addComponent(component);
      }
      const newApp = new FirebaseAppImpl(options, config, container);
      _apps.set(name, newApp);
      return newApp;
  }
  /**
   * Retrieves a {@link @firebase/app#FirebaseApp} instance.
   *
   * When called with no arguments, the default app is returned. When an app name
   * is provided, the app corresponding to that name is returned.
   *
   * An exception is thrown if the app being retrieved has not yet been
   * initialized.
   *
   * @example
   * ```javascript
   * // Return the default app
   * const app = getApp();
   * ```
   *
   * @example
   * ```javascript
   * // Return a named app
   * const otherApp = getApp("otherApp");
   * ```
   *
   * @param name - Optional name of the app to return. If no name is
   *   provided, the default is `"[DEFAULT]"`.
   *
   * @returns The app corresponding to the provided app name.
   *   If no app name is provided, the default app is returned.
   *
   * @public
   */
  function getApp(name = DEFAULT_ENTRY_NAME) {
      const app = _apps.get(name);
      if (!app) {
          throw ERROR_FACTORY.create("no-app" /* NO_APP */, { appName: name });
      }
      return app;
  }
  /**
   * A (read-only) array of all initialized apps.
   * @public
   */
  function getApps() {
      return Array.from(_apps.values());
  }
  /**
   * Renders this app unusable and frees the resources of all associated
   * services.
   *
   * @example
   * ```javascript
   * deleteApp(app)
   *   .then(function() {
   *     console.log("App deleted successfully");
   *   })
   *   .catch(function(error) {
   *     console.log("Error deleting app:", error);
   *   });
   * ```
   *
   * @public
   */
  async function deleteApp(app) {
      const name = app.name;
      if (_apps.has(name)) {
          _apps.delete(name);
          await Promise.all(app.container
              .getProviders()
              .map(provider => provider.delete()));
          app.isDeleted = true;
      }
  }
  /**
   * Registers a library's name and version for platform logging purposes.
   * @param library - Name of 1p or 3p library (e.g. firestore, angularfire)
   * @param version - Current version of that library.
   * @param variant - Bundle variant, e.g., node, rn, etc.
   *
   * @public
   */
  function registerVersion(libraryKeyOrName, version, variant) {
      var _a;
      // TODO: We can use this check to whitelist strings when/if we set up
      // a good whitelist system.
      let library = (_a = PLATFORM_LOG_STRING[libraryKeyOrName]) !== null && _a !== void 0 ? _a : libraryKeyOrName;
      if (variant) {
          library += `-${variant}`;
      }
      const libraryMismatch = library.match(/\s|\//);
      const versionMismatch = version.match(/\s|\//);
      if (libraryMismatch || versionMismatch) {
          const warning = [
              `Unable to register library "${library}" with version "${version}":`
          ];
          if (libraryMismatch) {
              warning.push(`library name "${library}" contains illegal characters (whitespace or "/")`);
          }
          if (libraryMismatch && versionMismatch) {
              warning.push('and');
          }
          if (versionMismatch) {
              warning.push(`version name "${version}" contains illegal characters (whitespace or "/")`);
          }
          logger.warn(warning.join(' '));
          return;
      }
      _registerComponent(new Component(`${library}-version`, () => ({ library, version }), "VERSION" /* VERSION */));
  }
  /**
   * Sets log handler for all Firebase SDKs.
   * @param logCallback - An optional custom log handler that executes user code whenever
   * the Firebase SDK makes a logging call.
   *
   * @public
   */
  function onLog(logCallback, options) {
      if (logCallback !== null && typeof logCallback !== 'function') {
          throw ERROR_FACTORY.create("invalid-log-argument" /* INVALID_LOG_ARGUMENT */);
      }
      setUserLogHandler(logCallback, options);
  }
  /**
   * Sets log level for all Firebase SDKs.
   *
   * All of the log types above the current log level are captured (i.e. if
   * you set the log level to `info`, errors are logged, but `debug` and
   * `verbose` logs are not).
   *
   * @public
   */
  function setLogLevel(logLevel) {
      setLogLevel$1(logLevel);
  }
  
  /**
   * @license
   * Copyright 2019 Google LLC
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  function registerCoreComponents(variant) {
      _registerComponent(new Component('platform-logger', container => new PlatformLoggerServiceImpl(container), "PRIVATE" /* PRIVATE */));
      // Register `app` package.
      registerVersion(name$o, version$1, variant);
      // Register platform SDK identifier (no version).
      registerVersion('fire-js', '');
  }
  
  /**
   * Firebase App
   *
   * @remarks This package coordinates the communication between the different Firebase components
   * @packageDocumentation
   */
  registerCoreComponents();
  
  export { SDK_VERSION, DEFAULT_ENTRY_NAME as _DEFAULT_ENTRY_NAME, _addComponent, _addOrOverwriteComponent, _apps, _clearComponents, _components, _getProvider, _registerComponent, _removeServiceInstance, deleteApp, getApp, getApps, initializeApp, onLog, registerVersion, setLogLevel };
  //# sourceMappingURL=index.esm2017.js.map
  