@firebase/database-compat 2.1.5-20260728185501 → 2.1.5-eap-crashlytics.64ada57eb

package/dist/index.standalone.js

@@ -10,10 +10,24 @@ var require$$1$1 = require('crypto');
 var require$$2$1 = require('url');
 var require$$1$2 = require('net');
 var require$$2$2 = require('tls');
-var require$$1$3 = require('@firebase/util');
-var require$$2$3 = require('@firebase/logger');
-var require$$3 = require('@firebase/app');
-var require$$4 = require('@firebase/component');
+var require$$2$3 = require('@firebase/util');
+var require$$1$3 = require('@firebase/logger');
+var require$$0$2 = require('@firebase/component');
+
+function getAugmentedNamespace(n) {
+	if (n.__esModule) return n;
+	var a = Object.defineProperty({}, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
 
 var index_standalone = {};
 
@@ -2216,7 +2230,7 @@ var Buffer$4     = safeBuffer.exports.Buffer,
 
 var PORTS = { 'ws:': 80, 'wss:': 443 };
 
-var Proxy$1 = function(client, origin, options) {
+var Proxy$2 = function(client, origin, options) {
   this._client  = client;
   this._http    = new HttpParser$2('response');
   this._origin  = (typeof client.url === 'object') ? client.url : url$2.parse(client.url);
@@ -2235,7 +2249,7 @@ var Proxy$1 = function(client, origin, options) {
   var auth = this._url.auth && Buffer$4.from(this._url.auth, 'utf8').toString('base64');
   if (auth) this._headers.set('Proxy-Authorization', 'Basic ' + auth);
 };
-util$9.inherits(Proxy$1, Stream$2);
+util$9.inherits(Proxy$2, Stream$2);
 
 var instance$6 = {
   setHeader: function(name, value) {
@@ -2300,9 +2314,9 @@ var instance$6 = {
 };
 
 for (var key$6 in instance$6)
-  Proxy$1.prototype[key$6] = instance$6[key$6];
+  Proxy$2.prototype[key$6] = instance$6[key$6];
 
-var proxy = Proxy$1;
+var proxy = Proxy$2;
 
 var Buffer$3     = safeBuffer.exports.Buffer,
     crypto$1     = require$$1$1,
@@ -2311,7 +2325,7 @@ var Buffer$3     = safeBuffer.exports.Buffer,
     HttpParser$1 = http_parser,
     Base$4       = base,
     Hybi$1       = hybi,
-    Proxy      = proxy;
+    Proxy$1      = proxy;
 
 var Client$2 = function(_url, options) {
   this.version = 'hybi-' + Hybi$1.VERSION;
@@ -2352,7 +2366,7 @@ var instance$5 = {
   VALID_PROTOCOLS: ['ws:', 'wss:'],
 
   proxy: function(origin, options) {
-    return new Proxy(this, origin, options);
+    return new Proxy$1(this, origin, options);
   },
 
   start: function() {
@@ -3345,13 +3359,1599 @@ WebSocket$1.EventSource = eventsource;
 
 var websocket        = WebSocket$1;
 
+var index_cjs = {};
+
+const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
+
+let idbProxyableTypes;
+let cursorAdvanceMethods;
+// This is a function to prevent it throwing up in node environments.
+function getIdbProxyableTypes() {
+    return (idbProxyableTypes ||
+        (idbProxyableTypes = [
+            IDBDatabase,
+            IDBObjectStore,
+            IDBIndex,
+            IDBCursor,
+            IDBTransaction,
+        ]));
+}
+// This is a function to prevent it throwing up in node environments.
+function getCursorAdvanceMethods() {
+    return (cursorAdvanceMethods ||
+        (cursorAdvanceMethods = [
+            IDBCursor.prototype.advance,
+            IDBCursor.prototype.continue,
+            IDBCursor.prototype.continuePrimaryKey,
+        ]));
+}
+const cursorRequestMap = new WeakMap();
+const transactionDoneMap = new WeakMap();
+const transactionStoreNamesMap = new WeakMap();
+const transformCache = new WeakMap();
+const reverseTransformCache = new WeakMap();
+function promisifyRequest(request) {
+    const promise = new Promise((resolve, reject) => {
+        const unlisten = () => {
+            request.removeEventListener('success', success);
+            request.removeEventListener('error', error);
+        };
+        const success = () => {
+            resolve(wrap(request.result));
+            unlisten();
+        };
+        const error = () => {
+            reject(request.error);
+            unlisten();
+        };
+        request.addEventListener('success', success);
+        request.addEventListener('error', error);
+    });
+    promise
+        .then((value) => {
+        // Since cursoring reuses the IDBRequest (*sigh*), we cache it for later retrieval
+        // (see wrapFunction).
+        if (value instanceof IDBCursor) {
+            cursorRequestMap.set(value, request);
+        }
+        // Catching to avoid "Uncaught Promise exceptions"
+    })
+        .catch(() => { });
+    // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This
+    // is because we create many promises from a single IDBRequest.
+    reverseTransformCache.set(promise, request);
+    return promise;
+}
+function cacheDonePromiseForTransaction(tx) {
+    // Early bail if we've already created a done promise for this transaction.
+    if (transactionDoneMap.has(tx))
+        return;
+    const done = new Promise((resolve, reject) => {
+        const unlisten = () => {
+            tx.removeEventListener('complete', complete);
+            tx.removeEventListener('error', error);
+            tx.removeEventListener('abort', error);
+        };
+        const complete = () => {
+            resolve();
+            unlisten();
+        };
+        const error = () => {
+            reject(tx.error || new DOMException('AbortError', 'AbortError'));
+            unlisten();
+        };
+        tx.addEventListener('complete', complete);
+        tx.addEventListener('error', error);
+        tx.addEventListener('abort', error);
+    });
+    // Cache it for later retrieval.
+    transactionDoneMap.set(tx, done);
+}
+let idbProxyTraps = {
+    get(target, prop, receiver) {
+        if (target instanceof IDBTransaction) {
+            // Special handling for transaction.done.
+            if (prop === 'done')
+                return transactionDoneMap.get(target);
+            // Polyfill for objectStoreNames because of Edge.
+            if (prop === 'objectStoreNames') {
+                return target.objectStoreNames || transactionStoreNamesMap.get(target);
+            }
+            // Make tx.store return the only store in the transaction, or undefined if there are many.
+            if (prop === 'store') {
+                return receiver.objectStoreNames[1]
+                    ? undefined
+                    : receiver.objectStore(receiver.objectStoreNames[0]);
+            }
+        }
+        // Else transform whatever we get back.
+        return wrap(target[prop]);
+    },
+    set(target, prop, value) {
+        target[prop] = value;
+        return true;
+    },
+    has(target, prop) {
+        if (target instanceof IDBTransaction &&
+            (prop === 'done' || prop === 'store')) {
+            return true;
+        }
+        return prop in target;
+    },
+};
+function replaceTraps(callback) {
+    idbProxyTraps = callback(idbProxyTraps);
+}
+function wrapFunction(func) {
+    // Due to expected object equality (which is enforced by the caching in `wrap`), we
+    // only create one new func per func.
+    // Edge doesn't support objectStoreNames (booo), so we polyfill it here.
+    if (func === IDBDatabase.prototype.transaction &&
+        !('objectStoreNames' in IDBTransaction.prototype)) {
+        return function (storeNames, ...args) {
+            const tx = func.call(unwrap(this), storeNames, ...args);
+            transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);
+            return wrap(tx);
+        };
+    }
+    // Cursor methods are special, as the behaviour is a little more different to standard IDB. In
+    // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the
+    // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense
+    // with real promises, so each advance methods returns a new promise for the cursor object, or
+    // undefined if the end of the cursor has been reached.
+    if (getCursorAdvanceMethods().includes(func)) {
+        return function (...args) {
+            // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+            // the original object.
+            func.apply(unwrap(this), args);
+            return wrap(cursorRequestMap.get(this));
+        };
+    }
+    return function (...args) {
+        // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+        // the original object.
+        return wrap(func.apply(unwrap(this), args));
+    };
+}
+function transformCachableValue(value) {
+    if (typeof value === 'function')
+        return wrapFunction(value);
+    // This doesn't return, it just creates a 'done' promise for the transaction,
+    // which is later returned for transaction.done (see idbObjectHandler).
+    if (value instanceof IDBTransaction)
+        cacheDonePromiseForTransaction(value);
+    if (instanceOfAny(value, getIdbProxyableTypes()))
+        return new Proxy(value, idbProxyTraps);
+    // Return the same value back if we're not going to transform it.
+    return value;
+}
+function wrap(value) {
+    // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
+    // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
+    if (value instanceof IDBRequest)
+        return promisifyRequest(value);
+    // If we've already transformed this value before, reuse the transformed value.
+    // This is faster, but it also provides object equality.
+    if (transformCache.has(value))
+        return transformCache.get(value);
+    const newValue = transformCachableValue(value);
+    // Not all types are transformed.
+    // These may be primitive types, so they can't be WeakMap keys.
+    if (newValue !== value) {
+        transformCache.set(value, newValue);
+        reverseTransformCache.set(newValue, value);
+    }
+    return newValue;
+}
+const unwrap = (value) => reverseTransformCache.get(value);
+
+/**
+ * Open a database.
+ *
+ * @param name Name of the database.
+ * @param version Schema version.
+ * @param callbacks Additional callbacks.
+ */
+function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
+    const request = indexedDB.open(name, version);
+    const openPromise = wrap(request);
+    if (upgrade) {
+        request.addEventListener('upgradeneeded', (event) => {
+            upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
+        });
+    }
+    if (blocked) {
+        request.addEventListener('blocked', (event) => blocked(
+        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+        event.oldVersion, event.newVersion, event));
+    }
+    openPromise
+        .then((db) => {
+        if (terminated)
+            db.addEventListener('close', () => terminated());
+        if (blocking) {
+            db.addEventListener('versionchange', (event) => blocking(event.oldVersion, event.newVersion, event));
+        }
+    })
+        .catch(() => { });
+    return openPromise;
+}
+/**
+ * Delete a database.
+ *
+ * @param name Name of the database.
+ */
+function deleteDB(name, { blocked } = {}) {
+    const request = indexedDB.deleteDatabase(name);
+    if (blocked) {
+        request.addEventListener('blocked', (event) => blocked(
+        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+        event.oldVersion, event));
+    }
+    return wrap(request).then(() => undefined);
+}
+
+const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
+const writeMethods = ['put', 'add', 'delete', 'clear'];
+const cachedMethods = new Map();
+function getMethod(target, prop) {
+    if (!(target instanceof IDBDatabase &&
+        !(prop in target) &&
+        typeof prop === 'string')) {
+        return;
+    }
+    if (cachedMethods.get(prop))
+        return cachedMethods.get(prop);
+    const targetFuncName = prop.replace(/FromIndex$/, '');
+    const useIndex = prop !== targetFuncName;
+    const isWrite = writeMethods.includes(targetFuncName);
+    if (
+    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
+    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) ||
+        !(isWrite || readMethods.includes(targetFuncName))) {
+        return;
+    }
+    const method = async function (storeName, ...args) {
+        // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(
+        const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');
+        let target = tx.store;
+        if (useIndex)
+            target = target.index(args.shift());
+        // Must reject if op rejects.
+        // If it's a write operation, must reject if tx.done rejects.
+        // Must reject with op rejection first.
+        // Must resolve with op value.
+        // Must handle both promises (no unhandled rejections)
+        return (await Promise.all([
+            target[targetFuncName](...args),
+            isWrite && tx.done,
+        ]))[0];
+    };
+    cachedMethods.set(prop, method);
+    return method;
+}
+replaceTraps((oldTraps) => ({
+    ...oldTraps,
+    get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+    has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop),
+}));
+
+var build = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	deleteDB: deleteDB,
+	openDB: openDB,
+	unwrap: unwrap,
+	wrap: wrap
+});
+
+var require$$3 = /*@__PURE__*/getAugmentedNamespace(build);
+
+(function (exports) {
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var component = require$$0$2;
+var logger$1 = require$$1$3;
+var util = require$$2$3;
+var idb = require$$3;
+
+/**
+ * @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?.type === "VERSION" /* ComponentType.VERSION */;
+}
+
+const name$r = "@firebase/app";
+const version$1 = "0.16.0-eap-crashlytics.64ada57eb";
+
+/**
+ * @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$1.Logger('@firebase/app');
+
+const name$q = "@firebase/app-compat";
+
+const name$p = "@firebase/analytics-compat";
+
+const name$o = "@firebase/analytics";
+
+const name$n = "@firebase/app-check-compat";
+
+const name$m = "@firebase/app-check";
+
+const name$l = "@firebase/auth";
+
+const name$k = "@firebase/auth-compat";
+
+const name$j = "@firebase/crashlytics";
+
+const name$i = "@firebase/database";
+
+const name$h = "@firebase/data-connect";
+
+const name$g = "@firebase/database-compat";
+
+const name$f = "@firebase/functions";
+
+const name$e = "@firebase/functions-compat";
+
+const name$d = "@firebase/installations";
+
+const name$c = "@firebase/installations-compat";
+
+const name$b = "@firebase/messaging";
+
+const name$a = "@firebase/messaging-compat";
+
+const name$9 = "@firebase/performance";
+
+const name$8 = "@firebase/performance-compat";
+
+const name$7 = "@firebase/remote-config";
+
+const name$6 = "@firebase/remote-config-compat";
+
+const name$5 = "@firebase/storage";
+
+const name$4 = "@firebase/storage-compat";
+
+const name$3 = "@firebase/firestore";
+
+const name$2 = "@firebase/ai";
+
+const name$1 = "@firebase/firestore-compat";
+
+const name = "firebase";
+const version = "12.17.0-eap-crashlytics.64ada57eb";
+
+/**
+ * @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$r]: 'fire-core',
+    [name$q]: 'fire-core-compat',
+    [name$o]: 'fire-analytics',
+    [name$p]: 'fire-analytics-compat',
+    [name$m]: 'fire-app-check',
+    [name$n]: 'fire-app-check-compat',
+    [name$l]: 'fire-auth',
+    [name$k]: 'fire-auth-compat',
+    [name$j]: 'fire-cls',
+    [name$i]: 'fire-rtdb',
+    [name$h]: 'fire-data-connect',
+    [name$g]: 'fire-rtdb-compat',
+    [name$f]: 'fire-fn',
+    [name$e]: 'fire-fn-compat',
+    [name$d]: 'fire-iid',
+    [name$c]: 'fire-iid-compat',
+    [name$b]: 'fire-fcm',
+    [name$a]: 'fire-fcm-compat',
+    [name$9]: 'fire-perf',
+    [name$8]: 'fire-perf-compat',
+    [name$7]: 'fire-rc',
+    [name$6]: 'fire-rc-compat',
+    [name$5]: 'fire-gcs',
+    [name$4]: 'fire-gcs-compat',
+    [name$3]: 'fire-fst',
+    [name$1]: 'fire-fst-compat',
+    [name$2]: 'fire-vertex',
+    'fire-js': 'fire-js', // Platform identifier for JS SDK.
+    [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();
+/**
+ * @internal
+ */
+const _serverApps = 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);
+    }
+    for (const serverApp of _serverApps.values()) {
+        _addComponent(serverApp, 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) {
+    const heartbeatController = app.container
+        .getProvider('heartbeat')
+        .getImmediate({ optional: true });
+    if (heartbeatController) {
+        void heartbeatController.triggerHeartbeat();
+    }
+    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);
+}
+/**
+ *
+ * @param obj - an object of type FirebaseApp, FirebaseOptions or FirebaseAppSettings.
+ *
+ * @returns true if the provide object is of type FirebaseApp.
+ *
+ * @internal
+ */
+function _isFirebaseApp(obj) {
+    return obj.options !== undefined;
+}
+/**
+ *
+ * @param obj - an object of type FirebaseApp, FirebaseOptions or FirebaseAppSettings.
+ *
+ * @returns true if the provided object is of type FirebaseServerAppImpl.
+ *
+ * @internal
+ */
+function _isFirebaseServerAppSettings(obj) {
+    if (_isFirebaseApp(obj)) {
+        return false;
+    }
+    return ('authIdToken' in obj ||
+        'appCheckToken' in obj ||
+        'releaseOnDeref' in obj ||
+        'automaticDataCollectionEnabled' in obj);
+}
+/**
+ *
+ * @param obj - an object of type FirebaseApp.
+ *
+ * @returns true if the provided object is of type FirebaseServerAppImpl.
+ *
+ * @internal
+ */
+function _isFirebaseServerApp(obj) {
+    if (obj === null || obj === undefined) {
+        return false;
+    }
+    return obj.settings !== undefined;
+}
+/**
+ * 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" /* AppError.NO_APP */]: "No Firebase App '{$appName}' has been created - " +
+        'call initializeApp() first',
+    ["bad-app-name" /* AppError.BAD_APP_NAME */]: "Illegal App name: '{$appName}'",
+    ["duplicate-app" /* AppError.DUPLICATE_APP */]: "Firebase App named '{$appName}' already exists with different {$mismatchedParam}." +
+        " Existing: '{$oldValue}'. New: '{$newValue}'.",
+    ["app-deleted" /* AppError.APP_DELETED */]: "Firebase App named '{$appName}' already deleted",
+    ["server-app-deleted" /* AppError.SERVER_APP_DELETED */]: 'Firebase Server App has been deleted',
+    ["no-options" /* AppError.NO_OPTIONS */]: 'Need to provide options, when not being deployed to hosting via source.',
+    ["invalid-app-argument" /* AppError.INVALID_APP_ARGUMENT */]: 'firebase.{$appName}() takes either no argument or a ' +
+        'Firebase App instance.',
+    ["invalid-log-argument" /* AppError.INVALID_LOG_ARGUMENT */]: 'First argument to `onLog` must be null or a function.',
+    ["idb-open" /* AppError.IDB_OPEN */]: 'Error thrown when opening IndexedDB. Original error: {$originalErrorMessage}.',
+    ["idb-get" /* AppError.IDB_GET */]: 'Error thrown when reading from IndexedDB. Original error: {$originalErrorMessage}.',
+    ["idb-set" /* AppError.IDB_WRITE */]: 'Error thrown when writing to IndexedDB. Original error: {$originalErrorMessage}.',
+    ["idb-delete" /* AppError.IDB_DELETE */]: 'Error thrown when deleting from IndexedDB. Original error: {$originalErrorMessage}.',
+    ["finalization-registry-not-supported" /* AppError.FINALIZATION_REGISTRY_NOT_SUPPORTED */]: 'FirebaseServerApp deleteOnDeref field defined but the JS runtime does not support FinalizationRegistry.',
+    ["invalid-server-app-environment" /* AppError.INVALID_SERVER_APP_ENVIRONMENT */]: 'FirebaseServerApp is not for use in browser environments.'
+};
+const ERROR_FACTORY = new util.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 = { ...options };
+        this._config = { ...config };
+        this._name = config.name;
+        this._automaticDataCollectionEnabled =
+            config.automaticDataCollectionEnabled;
+        this._container = container;
+        this.container.addComponent(new component.Component('app', () => this, "PUBLIC" /* ComponentType.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" /* AppError.APP_DELETED */, { appName: this._name });
+        }
+    }
+}
+
+/**
+ * @license
+ * Copyright 2023 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.
+ */
+// Parse the token and check to see if the `exp` claim is in the future.
+// Reports an error to the console if the token or claim could not be parsed, or if `exp` is in
+// the past.
+function validateTokenTTL(base64Token, tokenName) {
+    const secondPart = util.base64Decode(base64Token.split('.')[1]);
+    if (secondPart === null) {
+        console.error(`FirebaseServerApp ${tokenName} is invalid: second part could not be parsed.`);
+        return;
+    }
+    const expClaim = JSON.parse(secondPart).exp;
+    if (expClaim === undefined) {
+        console.error(`FirebaseServerApp ${tokenName} is invalid: expiration claim could not be parsed`);
+        return;
+    }
+    const exp = JSON.parse(secondPart).exp * 1000;
+    const now = new Date().getTime();
+    const diff = exp - now;
+    if (diff <= 0) {
+        console.error(`FirebaseServerApp ${tokenName} is invalid: the token has expired.`);
+    }
+}
+class FirebaseServerAppImpl extends FirebaseAppImpl {
+    constructor(options, serverConfig, name, container) {
+        // Build configuration parameters for the FirebaseAppImpl base class.
+        const automaticDataCollectionEnabled = serverConfig.automaticDataCollectionEnabled !== undefined
+            ? serverConfig.automaticDataCollectionEnabled
+            : true;
+        // Create the FirebaseAppSettings object for the FirebaseAppImp constructor.
+        const config = {
+            name,
+            automaticDataCollectionEnabled
+        };
+        if (options.apiKey !== undefined) {
+            // Construct the parent FirebaseAppImp object.
+            super(options, config, container);
+        }
+        else {
+            const appImpl = options;
+            super(appImpl.options, config, container);
+        }
+        // Now construct the data for the FirebaseServerAppImpl.
+        this._serverConfig = {
+            automaticDataCollectionEnabled,
+            ...serverConfig
+        };
+        // Ensure that the current time is within the `authIdtoken` window of validity.
+        if (this._serverConfig.authIdToken) {
+            validateTokenTTL(this._serverConfig.authIdToken, 'authIdToken');
+        }
+        // Ensure that the current time is within the `appCheckToken` window of validity.
+        if (this._serverConfig.appCheckToken) {
+            validateTokenTTL(this._serverConfig.appCheckToken, 'appCheckToken');
+        }
+        this._finalizationRegistry = null;
+        if (typeof FinalizationRegistry !== 'undefined') {
+            this._finalizationRegistry = new FinalizationRegistry(() => {
+                this.automaticCleanup();
+            });
+        }
+        this._refCount = 0;
+        this.incRefCount(this._serverConfig.releaseOnDeref);
+        // Do not retain a hard reference to the dref object, otherwise the FinalizationRegistry
+        // will never trigger.
+        this._serverConfig.releaseOnDeref = undefined;
+        serverConfig.releaseOnDeref = undefined;
+        registerVersion(name$r, version$1, 'serverapp');
+    }
+    toJSON() {
+        return undefined;
+    }
+    get refCount() {
+        return this._refCount;
+    }
+    // Increment the reference count of this server app. If an object is provided, register it
+    // with the finalization registry.
+    incRefCount(obj) {
+        if (this.isDeleted) {
+            return;
+        }
+        this._refCount++;
+        if (obj !== undefined && this._finalizationRegistry !== null) {
+            this._finalizationRegistry.register(obj, this);
+        }
+    }
+    // Decrement the reference count.
+    decRefCount() {
+        if (this.isDeleted) {
+            return 0;
+        }
+        return --this._refCount;
+    }
+    // Invoked by the FinalizationRegistry callback to note that this app should go through its
+    // reference counts and delete itself if no reference count remain. The coordinating logic that
+    // handles this is in deleteApp(...).
+    automaticCleanup() {
+        void deleteApp(this);
+    }
+    get settings() {
+        this.checkDestroyed();
+        return this._serverConfig;
+    }
+    /**
+     * 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("server-app-deleted" /* AppError.SERVER_APP_DELETED */);
+        }
+    }
+}
+
+/**
+ * @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 = {}) {
+    let options = _options;
+    if (typeof rawConfig !== 'object') {
+        const name = rawConfig;
+        rawConfig = { name };
+    }
+    const config = {
+        name: DEFAULT_ENTRY_NAME,
+        automaticDataCollectionEnabled: true,
+        ...rawConfig
+    };
+    const name = config.name;
+    if (typeof name !== 'string' || !name) {
+        throw ERROR_FACTORY.create("bad-app-name" /* AppError.BAD_APP_NAME */, {
+            appName: String(name)
+        });
+    }
+    options || (options = util.getDefaultAppConfig());
+    if (!options) {
+        throw ERROR_FACTORY.create("no-options" /* AppError.NO_OPTIONS */);
+    }
+    const existingApp = _apps.get(name);
+    if (existingApp) {
+        // return the existing app if options and config deep equal the ones in the existing app.
+        if (!util.deepEqual(options, existingApp.options)) {
+            throw ERROR_FACTORY.create("duplicate-app" /* AppError.DUPLICATE_APP */, {
+                appName: name,
+                mismatchedParam: 'options',
+                oldValue: JSON.stringify(existingApp.options),
+                newValue: JSON.stringify(options)
+            });
+        }
+        else if (!util.deepEqual(config, existingApp.config)) {
+            throw ERROR_FACTORY.create("duplicate-app" /* AppError.DUPLICATE_APP */, {
+                appName: name,
+                mismatchedParam: 'config',
+                oldValue: JSON.stringify(existingApp.config),
+                newValue: JSON.stringify(config)
+            });
+        }
+        else {
+            return existingApp;
+        }
+    }
+    const container = new component.ComponentContainer(name);
+    for (const component of _components.values()) {
+        container.addComponent(component);
+    }
+    const newApp = new FirebaseAppImpl(options, config, container);
+    _apps.set(name, newApp);
+    return newApp;
+}
+function initializeServerApp(_options, _serverAppConfig = {}) {
+    if (util.isBrowser() && !util.isWebWorker()) {
+        // FirebaseServerApp isn't designed to be run in browsers.
+        throw ERROR_FACTORY.create("invalid-server-app-environment" /* AppError.INVALID_SERVER_APP_ENVIRONMENT */);
+    }
+    let firebaseOptions;
+    let serverAppSettings = _serverAppConfig || {};
+    if (_options) {
+        if (_isFirebaseApp(_options)) {
+            firebaseOptions = _options.options;
+        }
+        else if (_isFirebaseServerAppSettings(_options)) {
+            serverAppSettings = _options;
+        }
+        else {
+            firebaseOptions = _options;
+        }
+    }
+    if (serverAppSettings.automaticDataCollectionEnabled === undefined) {
+        serverAppSettings.automaticDataCollectionEnabled = true;
+    }
+    firebaseOptions || (firebaseOptions = util.getDefaultAppConfig());
+    if (!firebaseOptions) {
+        throw ERROR_FACTORY.create("no-options" /* AppError.NO_OPTIONS */);
+    }
+    // Build an app name based on a hash of the configuration options.
+    const nameObj = {
+        ...serverAppSettings,
+        ...firebaseOptions
+    };
+    // However, Do not mangle the name based on releaseOnDeref, since it will vary between the
+    // construction of FirebaseServerApp instances. For example, if the object is the request headers.
+    if (nameObj.releaseOnDeref !== undefined) {
+        delete nameObj.releaseOnDeref;
+    }
+    const hashCode = (s) => {
+        return [...s].reduce((hash, c) => (Math.imul(31, hash) + c.charCodeAt(0)) | 0, 0);
+    };
+    if (serverAppSettings.releaseOnDeref !== undefined) {
+        if (typeof FinalizationRegistry === 'undefined') {
+            throw ERROR_FACTORY.create("finalization-registry-not-supported" /* AppError.FINALIZATION_REGISTRY_NOT_SUPPORTED */, {});
+        }
+    }
+    const nameString = '' + hashCode(JSON.stringify(nameObj));
+    const existingApp = _serverApps.get(nameString);
+    if (existingApp) {
+        existingApp.incRefCount(serverAppSettings.releaseOnDeref);
+        return existingApp;
+    }
+    const container = new component.ComponentContainer(nameString);
+    for (const component of _components.values()) {
+        container.addComponent(component);
+    }
+    const newApp = new FirebaseServerAppImpl(firebaseOptions, serverAppSettings, nameString, container);
+    _serverApps.set(nameString, 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 && name === DEFAULT_ENTRY_NAME && util.getDefaultAppConfig()) {
+        return initializeApp();
+    }
+    if (!app) {
+        throw ERROR_FACTORY.create("no-app" /* AppError.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) {
+    let cleanupProviders = false;
+    const name = app.name;
+    if (_apps.has(name)) {
+        cleanupProviders = true;
+        _apps.delete(name);
+    }
+    else if (_serverApps.has(name)) {
+        const firebaseServerApp = app;
+        if (firebaseServerApp.decRefCount() <= 0) {
+            _serverApps.delete(name);
+            cleanupProviders = true;
+        }
+    }
+    if (cleanupProviders) {
+        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) {
+    // TODO: We can use this check to whitelist strings when/if we set up
+    // a good whitelist system.
+    let library = PLATFORM_LOG_STRING[libraryKeyOrName] ?? 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.Component(`${library}-version`, () => ({ library, version }), "VERSION" /* ComponentType.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" /* AppError.INVALID_LOG_ARGUMENT */);
+    }
+    logger$1.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) {
+    logger$1.setLogLevel(logLevel);
+}
+
+/**
+ * @license
+ * Copyright 2021 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 DB_NAME = 'firebase-heartbeat-database';
+const DB_VERSION = 1;
+const STORE_NAME = 'firebase-heartbeat-store';
+let dbPromise = null;
+function getDbPromise() {
+    if (!dbPromise) {
+        dbPromise = idb.openDB(DB_NAME, DB_VERSION, {
+            upgrade: (db, oldVersion) => {
+                // We don't use 'break' in this switch statement, the fall-through
+                // behavior is what we want, because if there are multiple versions between
+                // the old version and the current version, we want ALL the migrations
+                // that correspond to those versions to run, not only the last one.
+                // eslint-disable-next-line default-case
+                switch (oldVersion) {
+                    case 0:
+                        try {
+                            db.createObjectStore(STORE_NAME);
+                        }
+                        catch (e) {
+                            // Safari/iOS browsers throw occasional exceptions on
+                            // db.createObjectStore() that may be a bug. Avoid blocking
+                            // the rest of the app functionality.
+                            console.warn(e);
+                        }
+                }
+            }
+        }).catch(e => {
+            throw ERROR_FACTORY.create("idb-open" /* AppError.IDB_OPEN */, {
+                originalErrorMessage: e.message
+            });
+        });
+    }
+    return dbPromise;
+}
+async function readHeartbeatsFromIndexedDB(app) {
+    try {
+        const db = await getDbPromise();
+        const tx = db.transaction(STORE_NAME);
+        const result = await tx.objectStore(STORE_NAME).get(computeKey(app));
+        // We already have the value but tx.done can throw,
+        // so we need to await it here to catch errors
+        await tx.done;
+        return result;
+    }
+    catch (e) {
+        if (e instanceof util.FirebaseError) {
+            logger.warn(e.message);
+        }
+        else {
+            const idbGetError = ERROR_FACTORY.create("idb-get" /* AppError.IDB_GET */, {
+                originalErrorMessage: e?.message
+            });
+            logger.warn(idbGetError.message);
+        }
+    }
+}
+async function writeHeartbeatsToIndexedDB(app, heartbeatObject) {
+    try {
+        const db = await getDbPromise();
+        const tx = db.transaction(STORE_NAME, 'readwrite');
+        const objectStore = tx.objectStore(STORE_NAME);
+        await objectStore.put(heartbeatObject, computeKey(app));
+        await tx.done;
+    }
+    catch (e) {
+        if (e instanceof util.FirebaseError) {
+            logger.warn(e.message);
+        }
+        else {
+            const idbGetError = ERROR_FACTORY.create("idb-set" /* AppError.IDB_WRITE */, {
+                originalErrorMessage: e?.message
+            });
+            logger.warn(idbGetError.message);
+        }
+    }
+}
+function computeKey(app) {
+    return `${app.name}!${app.options.appId}`;
+}
+
+/**
+ * @license
+ * Copyright 2021 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 MAX_HEADER_BYTES = 1024;
+const MAX_NUM_STORED_HEARTBEATS = 30;
+class HeartbeatServiceImpl {
+    constructor(container) {
+        this.container = container;
+        /**
+         * In-memory cache for heartbeats, used by getHeartbeatsHeader() to generate
+         * the header string.
+         * Stores one record per date. This will be consolidated into the standard
+         * format of one record per user agent string before being sent as a header.
+         * Populated from indexedDB when the controller is instantiated and should
+         * be kept in sync with indexedDB.
+         * Leave public for easier testing.
+         */
+        this._heartbeatsCache = null;
+        const app = this.container.getProvider('app').getImmediate();
+        this._storage = new HeartbeatStorageImpl(app);
+        this._heartbeatsCachePromise = this._storage.read().then(result => {
+            this._heartbeatsCache = result;
+            return result;
+        });
+    }
+    /**
+     * Called to report a heartbeat. The function will generate
+     * a HeartbeatsByUserAgent object, update heartbeatsCache, and persist it
+     * to IndexedDB.
+     * Note that we only store one heartbeat per day. So if a heartbeat for today is
+     * already logged, subsequent calls to this function in the same day will be ignored.
+     */
+    async triggerHeartbeat() {
+        try {
+            const platformLogger = this.container
+                .getProvider('platform-logger')
+                .getImmediate();
+            // This is the "Firebase user agent" string from the platform logger
+            // service, not the browser user agent.
+            const agent = platformLogger.getPlatformInfoString();
+            const date = getUTCDateString();
+            if (this._heartbeatsCache?.heartbeats == null) {
+                this._heartbeatsCache = await this._heartbeatsCachePromise;
+                // If we failed to construct a heartbeats cache, then return immediately.
+                if (this._heartbeatsCache?.heartbeats == null) {
+                    return;
+                }
+            }
+            // Do not store a heartbeat if one is already stored for this day
+            // or if a header has already been sent today.
+            if (this._heartbeatsCache.lastSentHeartbeatDate === date ||
+                this._heartbeatsCache.heartbeats.some(singleDateHeartbeat => singleDateHeartbeat.date === date)) {
+                return;
+            }
+            else {
+                // There is no entry for this date. Create one.
+                this._heartbeatsCache.heartbeats.push({ date, agent });
+                // If the number of stored heartbeats exceeds the maximum number of stored heartbeats, remove the heartbeat with the earliest date.
+                // Since this is executed each time a heartbeat is pushed, the limit can only be exceeded by one, so only one needs to be removed.
+                if (this._heartbeatsCache.heartbeats.length > MAX_NUM_STORED_HEARTBEATS) {
+                    const earliestHeartbeatIdx = getEarliestHeartbeatIdx(this._heartbeatsCache.heartbeats);
+                    this._heartbeatsCache.heartbeats.splice(earliestHeartbeatIdx, 1);
+                }
+            }
+            return this._storage.overwrite(this._heartbeatsCache);
+        }
+        catch (e) {
+            logger.warn(e);
+        }
+    }
+    /**
+     * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly.
+     * It also clears all heartbeats from memory as well as in IndexedDB.
+     *
+     * NOTE: Consuming product SDKs should not send the header if this method
+     * returns an empty string.
+     */
+    async getHeartbeatsHeader() {
+        try {
+            if (this._heartbeatsCache === null) {
+                await this._heartbeatsCachePromise;
+            }
+            // If it's still null or the array is empty, there is no data to send.
+            if (this._heartbeatsCache?.heartbeats == null ||
+                this._heartbeatsCache.heartbeats.length === 0) {
+                return '';
+            }
+            const date = getUTCDateString();
+            // Extract as many heartbeats from the cache as will fit under the size limit.
+            const { heartbeatsToSend, unsentEntries } = extractHeartbeatsForHeader(this._heartbeatsCache.heartbeats);
+            const headerString = util.base64urlEncodeWithoutPadding(JSON.stringify({ version: 2, heartbeats: heartbeatsToSend }));
+            // Store last sent date to prevent another being logged/sent for the same day.
+            this._heartbeatsCache.lastSentHeartbeatDate = date;
+            if (unsentEntries.length > 0) {
+                // Store any unsent entries if they exist.
+                this._heartbeatsCache.heartbeats = unsentEntries;
+                // This seems more likely than emptying the array (below) to lead to some odd state
+                // since the cache isn't empty and this will be called again on the next request,
+                // and is probably safest if we await it.
+                await this._storage.overwrite(this._heartbeatsCache);
+            }
+            else {
+                this._heartbeatsCache.heartbeats = [];
+                // Do not wait for this, to reduce latency.
+                void this._storage.overwrite(this._heartbeatsCache);
+            }
+            return headerString;
+        }
+        catch (e) {
+            logger.warn(e);
+            return '';
+        }
+    }
+}
+function getUTCDateString() {
+    const today = new Date();
+    // Returns date format 'YYYY-MM-DD'
+    return today.toISOString().substring(0, 10);
+}
+function extractHeartbeatsForHeader(heartbeatsCache, maxSize = MAX_HEADER_BYTES) {
+    // Heartbeats grouped by user agent in the standard format to be sent in
+    // the header.
+    const heartbeatsToSend = [];
+    // Single date format heartbeats that are not sent.
+    let unsentEntries = heartbeatsCache.slice();
+    for (const singleDateHeartbeat of heartbeatsCache) {
+        // Look for an existing entry with the same user agent.
+        const heartbeatEntry = heartbeatsToSend.find(hb => hb.agent === singleDateHeartbeat.agent);
+        if (!heartbeatEntry) {
+            // If no entry for this user agent exists, create one.
+            heartbeatsToSend.push({
+                agent: singleDateHeartbeat.agent,
+                dates: [singleDateHeartbeat.date]
+            });
+            if (countBytes(heartbeatsToSend) > maxSize) {
+                // If the header would exceed max size, remove the added heartbeat
+                // entry and stop adding to the header.
+                heartbeatsToSend.pop();
+                break;
+            }
+        }
+        else {
+            heartbeatEntry.dates.push(singleDateHeartbeat.date);
+            // If the header would exceed max size, remove the added date
+            // and stop adding to the header.
+            if (countBytes(heartbeatsToSend) > maxSize) {
+                heartbeatEntry.dates.pop();
+                break;
+            }
+        }
+        // Pop unsent entry from queue. (Skipped if adding the entry exceeded
+        // quota and the loop breaks early.)
+        unsentEntries = unsentEntries.slice(1);
+    }
+    return {
+        heartbeatsToSend,
+        unsentEntries
+    };
+}
+class HeartbeatStorageImpl {
+    constructor(app) {
+        this.app = app;
+        this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();
+    }
+    async runIndexedDBEnvironmentCheck() {
+        if (!util.isIndexedDBAvailable()) {
+            return false;
+        }
+        else {
+            return util.validateIndexedDBOpenable()
+                .then(() => true)
+                .catch(() => false);
+        }
+    }
+    /**
+     * Read all heartbeats.
+     */
+    async read() {
+        const canUseIndexedDB = await this._canUseIndexedDBPromise;
+        if (!canUseIndexedDB) {
+            return { heartbeats: [] };
+        }
+        else {
+            const idbHeartbeatObject = await readHeartbeatsFromIndexedDB(this.app);
+            if (idbHeartbeatObject?.heartbeats) {
+                return idbHeartbeatObject;
+            }
+            else {
+                return { heartbeats: [] };
+            }
+        }
+    }
+    // overwrite the storage with the provided heartbeats
+    async overwrite(heartbeatsObject) {
+        const canUseIndexedDB = await this._canUseIndexedDBPromise;
+        if (!canUseIndexedDB) {
+            return;
+        }
+        else {
+            const existingHeartbeatsObject = await this.read();
+            return writeHeartbeatsToIndexedDB(this.app, {
+                lastSentHeartbeatDate: heartbeatsObject.lastSentHeartbeatDate ??
+                    existingHeartbeatsObject.lastSentHeartbeatDate,
+                heartbeats: heartbeatsObject.heartbeats
+            });
+        }
+    }
+    // add heartbeats
+    async add(heartbeatsObject) {
+        const canUseIndexedDB = await this._canUseIndexedDBPromise;
+        if (!canUseIndexedDB) {
+            return;
+        }
+        else {
+            const existingHeartbeatsObject = await this.read();
+            return writeHeartbeatsToIndexedDB(this.app, {
+                lastSentHeartbeatDate: heartbeatsObject.lastSentHeartbeatDate ??
+                    existingHeartbeatsObject.lastSentHeartbeatDate,
+                heartbeats: [
+                    ...existingHeartbeatsObject.heartbeats,
+                    ...heartbeatsObject.heartbeats
+                ]
+            });
+        }
+    }
+}
+/**
+ * Calculate bytes of a HeartbeatsByUserAgent array after being wrapped
+ * in a platform logging header JSON object, stringified, and converted
+ * to base 64.
+ */
+function countBytes(heartbeatsCache) {
+    // base64 has a restricted set of characters, all of which should be 1 byte.
+    return util.base64urlEncodeWithoutPadding(
+    // heartbeatsCache wrapper properties
+    JSON.stringify({ version: 2, heartbeats: heartbeatsCache })).length;
+}
+/**
+ * Returns the index of the heartbeat with the earliest date.
+ * If the heartbeats array is empty, -1 is returned.
+ */
+function getEarliestHeartbeatIdx(heartbeats) {
+    if (heartbeats.length === 0) {
+        return -1;
+    }
+    let earliestHeartbeatIdx = 0;
+    let earliestHeartbeatDate = heartbeats[0].date;
+    for (let i = 1; i < heartbeats.length; i++) {
+        if (heartbeats[i].date < earliestHeartbeatDate) {
+            earliestHeartbeatDate = heartbeats[i].date;
+            earliestHeartbeatIdx = i;
+        }
+    }
+    return earliestHeartbeatIdx;
+}
+
+/**
+ * @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.Component('platform-logger', container => new PlatformLoggerServiceImpl(container), "PRIVATE" /* ComponentType.PRIVATE */));
+    _registerComponent(new component.Component('heartbeat', container => new HeartbeatServiceImpl(container), "PRIVATE" /* ComponentType.PRIVATE */));
+    // Register `app` package.
+    registerVersion(name$r, version$1, variant);
+    // BUILD_TARGET will be replaced by values like esm, cjs, etc during the compilation
+    registerVersion(name$r, version$1, 'cjs2020');
+    // Register platform SDK identifier (no version).
+    registerVersion('fire-js', '');
+}
+
+/**
+ * Firebase App
+ *
+ * @remarks This package coordinates the communication between the different Firebase components
+ * @packageDocumentation
+ */
+/**
+ * @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.
+ */
+registerCoreComponents('node');
+
+Object.defineProperty(exports, "FirebaseError", {
+  enumerable: true,
+  get: function () { return util.FirebaseError; }
+});
+exports.SDK_VERSION = SDK_VERSION;
+exports._DEFAULT_ENTRY_NAME = DEFAULT_ENTRY_NAME;
+exports._addComponent = _addComponent;
+exports._addOrOverwriteComponent = _addOrOverwriteComponent;
+exports._apps = _apps;
+exports._clearComponents = _clearComponents;
+exports._components = _components;
+exports._getProvider = _getProvider;
+exports._isFirebaseApp = _isFirebaseApp;
+exports._isFirebaseServerApp = _isFirebaseServerApp;
+exports._isFirebaseServerAppSettings = _isFirebaseServerAppSettings;
+exports._registerComponent = _registerComponent;
+exports._removeServiceInstance = _removeServiceInstance;
+exports._serverApps = _serverApps;
+exports.deleteApp = deleteApp;
+exports.getApp = getApp;
+exports.getApps = getApps;
+exports.initializeApp = initializeApp;
+exports.initializeServerApp = initializeServerApp;
+exports.onLog = onLog;
+exports.registerVersion = registerVersion;
+exports.setLogLevel = setLogLevel;
+
+}(index_cjs));
+
 Object.defineProperty(index_standalone, '__esModule', { value: true });
 
 var Websocket = websocket;
-var util = require$$1$3;
-var logger$1 = require$$2$3;
-var app = require$$3;
-var component = require$$4;
+var util = require$$2$3;
+var logger$1 = require$$1$3;
+var app = index_cjs;
+var component = require$$0$2;
 
 /**
  * @license
@@ -17394,7 +18994,7 @@ var update_1 = index_standalone.update = update;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const logClient = new require$$2$3.Logger('@firebase/database-compat');
+const logClient = new require$$1$3.Logger('@firebase/database-compat');
 const warn = function (msg) {
     const message = 'FIREBASE WARNING: ' + msg;
     logClient.warn(message);
@@ -17421,7 +19021,7 @@ const validateBoolean = function (fnName, argumentName, bool, optional) {
         return;
     }
     if (typeof bool !== 'boolean') {
-        throw new Error(require$$1$3.errorPrefix(fnName, argumentName) + 'must be a boolean.');
+        throw new Error(require$$2$3.errorPrefix(fnName, argumentName) + 'must be a boolean.');
     }
 };
 const validateEventType = function (fnName, eventType, optional) {
@@ -17436,7 +19036,7 @@ const validateEventType = function (fnName, eventType, optional) {
         case 'child_moved':
             break;
         default:
-            throw new Error(require$$1$3.errorPrefix(fnName, 'eventType') +
+            throw new Error(require$$2$3.errorPrefix(fnName, 'eventType') +
                 'must be a valid event type = "value", "child_added", "child_removed", ' +
                 '"child_changed", or "child_moved".');
     }
@@ -17463,8 +19063,8 @@ class OnDisconnect {
         this._delegate = _delegate;
     }
     cancel(onComplete) {
-        require$$1$3.validateArgCount('OnDisconnect.cancel', 0, 1, arguments.length);
-        require$$1$3.validateCallback('OnDisconnect.cancel', 'onComplete', onComplete, true);
+        require$$2$3.validateArgCount('OnDisconnect.cancel', 0, 1, arguments.length);
+        require$$2$3.validateCallback('OnDisconnect.cancel', 'onComplete', onComplete, true);
         const result = this._delegate.cancel();
         if (onComplete) {
             result.then(() => onComplete(null), error => onComplete(error));
@@ -17472,8 +19072,8 @@ class OnDisconnect {
         return result;
     }
     remove(onComplete) {
-        require$$1$3.validateArgCount('OnDisconnect.remove', 0, 1, arguments.length);
-        require$$1$3.validateCallback('OnDisconnect.remove', 'onComplete', onComplete, true);
+        require$$2$3.validateArgCount('OnDisconnect.remove', 0, 1, arguments.length);
+        require$$2$3.validateCallback('OnDisconnect.remove', 'onComplete', onComplete, true);
         const result = this._delegate.remove();
         if (onComplete) {
             result.then(() => onComplete(null), error => onComplete(error));
@@ -17481,8 +19081,8 @@ class OnDisconnect {
         return result;
     }
     set(value, onComplete) {
-        require$$1$3.validateArgCount('OnDisconnect.set', 1, 2, arguments.length);
-        require$$1$3.validateCallback('OnDisconnect.set', 'onComplete', onComplete, true);
+        require$$2$3.validateArgCount('OnDisconnect.set', 1, 2, arguments.length);
+        require$$2$3.validateCallback('OnDisconnect.set', 'onComplete', onComplete, true);
         const result = this._delegate.set(value);
         if (onComplete) {
             result.then(() => onComplete(null), error => onComplete(error));
@@ -17490,8 +19090,8 @@ class OnDisconnect {
         return result;
     }
     setWithPriority(value, priority, onComplete) {
-        require$$1$3.validateArgCount('OnDisconnect.setWithPriority', 2, 3, arguments.length);
-        require$$1$3.validateCallback('OnDisconnect.setWithPriority', 'onComplete', onComplete, true);
+        require$$2$3.validateArgCount('OnDisconnect.setWithPriority', 2, 3, arguments.length);
+        require$$2$3.validateCallback('OnDisconnect.setWithPriority', 'onComplete', onComplete, true);
         const result = this._delegate.setWithPriority(value, priority);
         if (onComplete) {
             result.then(() => onComplete(null), error => onComplete(error));
@@ -17499,7 +19099,7 @@ class OnDisconnect {
         return result;
     }
     update(objectToMerge, onComplete) {
-        require$$1$3.validateArgCount('OnDisconnect.update', 1, 2, arguments.length);
+        require$$2$3.validateArgCount('OnDisconnect.update', 1, 2, arguments.length);
         if (Array.isArray(objectToMerge)) {
             const newObjectToMerge = {};
             for (let i = 0; i < objectToMerge.length; ++i) {
@@ -17509,7 +19109,7 @@ class OnDisconnect {
             warn('Passing an Array to firebase.database.onDisconnect().update() is deprecated. Use set() if you want to overwrite the ' +
                 'existing data, or an Object with integer keys if you really do want to only update some of the children.');
         }
-        require$$1$3.validateCallback('OnDisconnect.update', 'onComplete', onComplete, true);
+        require$$2$3.validateCallback('OnDisconnect.update', 'onComplete', onComplete, true);
         const result = this._delegate.update(objectToMerge);
         if (onComplete) {
             result.then(() => onComplete(null), error => onComplete(error));
@@ -17545,7 +19145,7 @@ class TransactionResult {
     // Do not create public documentation. This is intended to make JSON serialization work but is otherwise unnecessary
     // for end-users
     toJSON() {
-        require$$1$3.validateArgCount('TransactionResult.toJSON', 0, 1, arguments.length);
+        require$$2$3.validateArgCount('TransactionResult.toJSON', 0, 1, arguments.length);
         return { committed: this.committed, snapshot: this.snapshot.toJSON() };
     }
 }
@@ -17582,7 +19182,7 @@ class DataSnapshot {
      * @returns JSON representation of the DataSnapshot contents, or null if empty.
      */
     val() {
-        require$$1$3.validateArgCount('DataSnapshot.val', 0, 0, arguments.length);
+        require$$2$3.validateArgCount('DataSnapshot.val', 0, 0, arguments.length);
         return this._delegate.val();
     }
     /**
@@ -17591,14 +19191,14 @@ class DataSnapshot {
      * @returns JSON representation of the DataSnapshot contents, or null if empty.
      */
     exportVal() {
-        require$$1$3.validateArgCount('DataSnapshot.exportVal', 0, 0, arguments.length);
+        require$$2$3.validateArgCount('DataSnapshot.exportVal', 0, 0, arguments.length);
         return this._delegate.exportVal();
     }
     // Do not create public documentation. This is intended to make JSON serialization work but is otherwise unnecessary
     // for end-users
     toJSON() {
         // Optional spacer argument is unnecessary because we're depending on recursion rather than stringifying the content
-        require$$1$3.validateArgCount('DataSnapshot.toJSON', 0, 1, arguments.length);
+        require$$2$3.validateArgCount('DataSnapshot.toJSON', 0, 1, arguments.length);
         return this._delegate.toJSON();
     }
     /**
@@ -17607,7 +19207,7 @@ class DataSnapshot {
      * @returns Whether the snapshot contains a non-null value, or is empty.
      */
     exists() {
-        require$$1$3.validateArgCount('DataSnapshot.exists', 0, 0, arguments.length);
+        require$$2$3.validateArgCount('DataSnapshot.exists', 0, 0, arguments.length);
         return this._delegate.exists();
     }
     /**
@@ -17617,7 +19217,7 @@ class DataSnapshot {
      * @returns DataSnapshot for child node.
      */
     child(path) {
-        require$$1$3.validateArgCount('DataSnapshot.child', 0, 1, arguments.length);
+        require$$2$3.validateArgCount('DataSnapshot.child', 0, 1, arguments.length);
         // Ensure the childPath is a string (can be a number)
         path = String(path);
         _validatePathString('DataSnapshot.child', 'path', path, false);
@@ -17630,7 +19230,7 @@ class DataSnapshot {
      * @returns Whether the child exists.
      */
     hasChild(path) {
-        require$$1$3.validateArgCount('DataSnapshot.hasChild', 1, 1, arguments.length);
+        require$$2$3.validateArgCount('DataSnapshot.hasChild', 1, 1, arguments.length);
         _validatePathString('DataSnapshot.hasChild', 'path', path, false);
         return this._delegate.hasChild(path);
     }
@@ -17640,7 +19240,7 @@ class DataSnapshot {
      * @returns The priority.
      */
     getPriority() {
-        require$$1$3.validateArgCount('DataSnapshot.getPriority', 0, 0, arguments.length);
+        require$$2$3.validateArgCount('DataSnapshot.getPriority', 0, 0, arguments.length);
         return this._delegate.priority;
     }
     /**
@@ -17652,8 +19252,8 @@ class DataSnapshot {
      * one of the child nodes.
      */
     forEach(action) {
-        require$$1$3.validateArgCount('DataSnapshot.forEach', 1, 1, arguments.length);
-        require$$1$3.validateCallback('DataSnapshot.forEach', 'action', action, false);
+        require$$2$3.validateArgCount('DataSnapshot.forEach', 1, 1, arguments.length);
+        require$$2$3.validateCallback('DataSnapshot.forEach', 'action', action, false);
         return this._delegate.forEach(expDataSnapshot => action(new DataSnapshot(this._database, expDataSnapshot)));
     }
     /**
@@ -17661,7 +19261,7 @@ class DataSnapshot {
      * @returns True if the DataSnapshot contains 1 or more child nodes.
      */
     hasChildren() {
-        require$$1$3.validateArgCount('DataSnapshot.hasChildren', 0, 0, arguments.length);
+        require$$2$3.validateArgCount('DataSnapshot.hasChildren', 0, 0, arguments.length);
         return this._delegate.hasChildren();
     }
     get key() {
@@ -17672,7 +19272,7 @@ class DataSnapshot {
      * @returns The number of children that this DataSnapshot contains.
      */
     numChildren() {
-        require$$1$3.validateArgCount('DataSnapshot.numChildren', 0, 0, arguments.length);
+        require$$2$3.validateArgCount('DataSnapshot.numChildren', 0, 0, arguments.length);
         return this._delegate.size;
     }
     /**
@@ -17680,7 +19280,7 @@ class DataSnapshot {
      * from.
      */
     getRef() {
-        require$$1$3.validateArgCount('DataSnapshot.ref', 0, 0, arguments.length);
+        require$$2$3.validateArgCount('DataSnapshot.ref', 0, 0, arguments.length);
         return new Reference(this._database, this._delegate.ref);
     }
     get ref() {
@@ -17699,8 +19299,8 @@ class Query {
         this._delegate = _delegate;
     }
     on(eventType, callback, cancelCallbackOrContext, context) {
-        require$$1$3.validateArgCount('Query.on', 2, 4, arguments.length);
-        require$$1$3.validateCallback('Query.on', 'callback', callback, false);
+        require$$2$3.validateArgCount('Query.on', 2, 4, arguments.length);
+        require$$2$3.validateCallback('Query.on', 'callback', callback, false);
         const ret = Query.getCancelAndContextArgs_('Query.on', cancelCallbackOrContext, context);
         const valueCallback = (expSnapshot, previousChildName) => {
             callback.call(ret.context, new DataSnapshot(this.database, expSnapshot), previousChildName);
@@ -17725,16 +19325,16 @@ class Query {
                 onChildMoved_1(this._delegate, valueCallback, cancelCallback);
                 return callback;
             default:
-                throw new Error(require$$1$3.errorPrefix('Query.on', 'eventType') +
+                throw new Error(require$$2$3.errorPrefix('Query.on', 'eventType') +
                     'must be a valid event type = "value", "child_added", "child_removed", ' +
                     '"child_changed", or "child_moved".');
         }
     }
     off(eventType, callback, context) {
-        require$$1$3.validateArgCount('Query.off', 0, 3, arguments.length);
+        require$$2$3.validateArgCount('Query.off', 0, 3, arguments.length);
         validateEventType('Query.off', eventType);
-        require$$1$3.validateCallback('Query.off', 'callback', callback, true);
-        require$$1$3.validateContextObject('Query.off', 'context', context, true);
+        require$$2$3.validateCallback('Query.off', 'callback', callback, true);
+        require$$2$3.validateContextObject('Query.off', 'context', context, true);
         if (callback) {
             const valueCallback = () => { };
             valueCallback.userCallback = callback;
@@ -17757,10 +19357,10 @@ class Query {
      * Attaches a listener, waits for the first event, and then removes the listener
      */
     once(eventType, callback, failureCallbackOrContext, context) {
-        require$$1$3.validateArgCount('Query.once', 1, 4, arguments.length);
-        require$$1$3.validateCallback('Query.once', 'callback', callback, true);
+        require$$2$3.validateArgCount('Query.once', 1, 4, arguments.length);
+        require$$2$3.validateCallback('Query.once', 'callback', callback, true);
         const ret = Query.getCancelAndContextArgs_('Query.once', failureCallbackOrContext, context);
-        const deferred = new require$$1$3.Deferred();
+        const deferred = new require$$2$3.Deferred();
         const valueCallback = (expSnapshot, previousChildName) => {
             const result = new DataSnapshot(this.database, expSnapshot);
             if (callback) {
@@ -17803,7 +19403,7 @@ class Query {
                 });
                 break;
             default:
-                throw new Error(require$$1$3.errorPrefix('Query.once', 'eventType') +
+                throw new Error(require$$2$3.errorPrefix('Query.once', 'eventType') +
                     'must be a valid event type = "value", "child_added", "child_removed", ' +
                     '"child_changed", or "child_moved".');
         }
@@ -17813,58 +19413,58 @@ class Query {
      * Set a limit and anchor it to the start of the window.
      */
     limitToFirst(limit) {
-        require$$1$3.validateArgCount('Query.limitToFirst', 1, 1, arguments.length);
+        require$$2$3.validateArgCount('Query.limitToFirst', 1, 1, arguments.length);
         return new Query(this.database, query_1(this._delegate, limitToFirst_1(limit)));
     }
     /**
      * Set a limit and anchor it to the end of the window.
      */
     limitToLast(limit) {
-        require$$1$3.validateArgCount('Query.limitToLast', 1, 1, arguments.length);
+        require$$2$3.validateArgCount('Query.limitToLast', 1, 1, arguments.length);
         return new Query(this.database, query_1(this._delegate, limitToLast_1(limit)));
     }
     /**
      * Given a child path, return a new query ordered by the specified grandchild path.
      */
     orderByChild(path) {
-        require$$1$3.validateArgCount('Query.orderByChild', 1, 1, arguments.length);
+        require$$2$3.validateArgCount('Query.orderByChild', 1, 1, arguments.length);
         return new Query(this.database, query_1(this._delegate, orderByChild_1(path)));
     }
     /**
      * Return a new query ordered by the KeyIndex
      */
     orderByKey() {
-        require$$1$3.validateArgCount('Query.orderByKey', 0, 0, arguments.length);
+        require$$2$3.validateArgCount('Query.orderByKey', 0, 0, arguments.length);
         return new Query(this.database, query_1(this._delegate, orderByKey_1()));
     }
     /**
      * Return a new query ordered by the PriorityIndex
      */
     orderByPriority() {
-        require$$1$3.validateArgCount('Query.orderByPriority', 0, 0, arguments.length);
+        require$$2$3.validateArgCount('Query.orderByPriority', 0, 0, arguments.length);
         return new Query(this.database, query_1(this._delegate, orderByPriority_1()));
     }
     /**
      * Return a new query ordered by the ValueIndex
      */
     orderByValue() {
-        require$$1$3.validateArgCount('Query.orderByValue', 0, 0, arguments.length);
+        require$$2$3.validateArgCount('Query.orderByValue', 0, 0, arguments.length);
         return new Query(this.database, query_1(this._delegate, orderByValue_1()));
     }
     startAt(value = null, name) {
-        require$$1$3.validateArgCount('Query.startAt', 0, 2, arguments.length);
+        require$$2$3.validateArgCount('Query.startAt', 0, 2, arguments.length);
         return new Query(this.database, query_1(this._delegate, startAt_1(value, name)));
     }
     startAfter(value = null, name) {
-        require$$1$3.validateArgCount('Query.startAfter', 0, 2, arguments.length);
+        require$$2$3.validateArgCount('Query.startAfter', 0, 2, arguments.length);
         return new Query(this.database, query_1(this._delegate, startAfter_1(value, name)));
     }
     endAt(value = null, name) {
-        require$$1$3.validateArgCount('Query.endAt', 0, 2, arguments.length);
+        require$$2$3.validateArgCount('Query.endAt', 0, 2, arguments.length);
         return new Query(this.database, query_1(this._delegate, endAt_1(value, name)));
     }
     endBefore(value = null, name) {
-        require$$1$3.validateArgCount('Query.endBefore', 0, 2, arguments.length);
+        require$$2$3.validateArgCount('Query.endBefore', 0, 2, arguments.length);
         return new Query(this.database, query_1(this._delegate, endBefore_1(value, name)));
     }
     /**
@@ -17872,28 +19472,28 @@ class Query {
      * the specified name.
      */
     equalTo(value, name) {
-        require$$1$3.validateArgCount('Query.equalTo', 1, 2, arguments.length);
+        require$$2$3.validateArgCount('Query.equalTo', 1, 2, arguments.length);
         return new Query(this.database, query_1(this._delegate, equalTo_1(value, name)));
     }
     /**
      * @returns URL for this location.
      */
     toString() {
-        require$$1$3.validateArgCount('Query.toString', 0, 0, arguments.length);
+        require$$2$3.validateArgCount('Query.toString', 0, 0, arguments.length);
         return this._delegate.toString();
     }
     // Do not create public documentation. This is intended to make JSON serialization work but is otherwise unnecessary
     // for end-users.
     toJSON() {
         // An optional spacer argument is unnecessary for a string.
-        require$$1$3.validateArgCount('Query.toJSON', 0, 1, arguments.length);
+        require$$2$3.validateArgCount('Query.toJSON', 0, 1, arguments.length);
         return this._delegate.toJSON();
     }
     /**
      * Return true if this query and the provided query are equivalent; otherwise, return false.
      */
     isEqual(other) {
-        require$$1$3.validateArgCount('Query.isEqual', 1, 1, arguments.length);
+        require$$2$3.validateArgCount('Query.isEqual', 1, 1, arguments.length);
         if (!(other instanceof Query)) {
             const error = 'Query.isEqual failed: First argument must be an instance of firebase.database.Query.';
             throw new Error(error);
@@ -17909,9 +19509,9 @@ class Query {
         const ret = { cancel: undefined, context: undefined };
         if (cancelOrContext && context) {
             ret.cancel = cancelOrContext;
-            require$$1$3.validateCallback(fnName, 'cancel', ret.cancel, true);
+            require$$2$3.validateCallback(fnName, 'cancel', ret.cancel, true);
             ret.context = context;
-            require$$1$3.validateContextObject(fnName, 'context', ret.context, true);
+            require$$2$3.validateContextObject(fnName, 'context', ret.context, true);
         }
         else if (cancelOrContext) {
             // we have either a cancel callback or a context.
@@ -17923,7 +19523,7 @@ class Query {
                 ret.cancel = cancelOrContext;
             }
             else {
-                throw new Error(require$$1$3.errorPrefix(fnName, 'cancelOrContext') +
+                throw new Error(require$$2$3.errorPrefix(fnName, 'cancelOrContext') +
                     ' must either be a cancel callback or a context object.');
             }
         }
@@ -17948,11 +19548,11 @@ class Reference extends Query {
     }
     /** @returns {?string} */
     getKey() {
-        require$$1$3.validateArgCount('Reference.key', 0, 0, arguments.length);
+        require$$2$3.validateArgCount('Reference.key', 0, 0, arguments.length);
         return this._delegate.key;
     }
     child(pathString) {
-        require$$1$3.validateArgCount('Reference.child', 1, 1, arguments.length);
+        require$$2$3.validateArgCount('Reference.child', 1, 1, arguments.length);
         if (typeof pathString === 'number') {
             pathString = String(pathString);
         }
@@ -17960,18 +19560,18 @@ class Reference extends Query {
     }
     /** @returns {?Reference} */
     getParent() {
-        require$$1$3.validateArgCount('Reference.parent', 0, 0, arguments.length);
+        require$$2$3.validateArgCount('Reference.parent', 0, 0, arguments.length);
         const parent = this._delegate.parent;
         return parent ? new Reference(this.database, parent) : null;
     }
     /** @returns {!Reference} */
     getRoot() {
-        require$$1$3.validateArgCount('Reference.root', 0, 0, arguments.length);
+        require$$2$3.validateArgCount('Reference.root', 0, 0, arguments.length);
         return new Reference(this.database, this._delegate.root);
     }
     set(newVal, onComplete) {
-        require$$1$3.validateArgCount('Reference.set', 1, 2, arguments.length);
-        require$$1$3.validateCallback('Reference.set', 'onComplete', onComplete, true);
+        require$$2$3.validateArgCount('Reference.set', 1, 2, arguments.length);
+        require$$2$3.validateCallback('Reference.set', 'onComplete', onComplete, true);
         const result = set_1(this._delegate, newVal);
         if (onComplete) {
             result.then(() => onComplete(null), error => onComplete(error));
@@ -17979,7 +19579,7 @@ class Reference extends Query {
         return result;
     }
     update(values, onComplete) {
-        require$$1$3.validateArgCount('Reference.update', 1, 2, arguments.length);
+        require$$2$3.validateArgCount('Reference.update', 1, 2, arguments.length);
         if (Array.isArray(values)) {
             const newObjectToMerge = {};
             for (let i = 0; i < values.length; ++i) {
@@ -17992,7 +19592,7 @@ class Reference extends Query {
                 'only update some of the children.');
         }
         _validateWritablePath('Reference.update', this._delegate._path);
-        require$$1$3.validateCallback('Reference.update', 'onComplete', onComplete, true);
+        require$$2$3.validateCallback('Reference.update', 'onComplete', onComplete, true);
         const result = update_1(this._delegate, values);
         if (onComplete) {
             result.then(() => onComplete(null), error => onComplete(error));
@@ -18000,8 +19600,8 @@ class Reference extends Query {
         return result;
     }
     setWithPriority(newVal, newPriority, onComplete) {
-        require$$1$3.validateArgCount('Reference.setWithPriority', 2, 3, arguments.length);
-        require$$1$3.validateCallback('Reference.setWithPriority', 'onComplete', onComplete, true);
+        require$$2$3.validateArgCount('Reference.setWithPriority', 2, 3, arguments.length);
+        require$$2$3.validateCallback('Reference.setWithPriority', 'onComplete', onComplete, true);
         const result = setWithPriority_1(this._delegate, newVal, newPriority);
         if (onComplete) {
             result.then(() => onComplete(null), error => onComplete(error));
@@ -18009,8 +19609,8 @@ class Reference extends Query {
         return result;
     }
     remove(onComplete) {
-        require$$1$3.validateArgCount('Reference.remove', 0, 1, arguments.length);
-        require$$1$3.validateCallback('Reference.remove', 'onComplete', onComplete, true);
+        require$$2$3.validateArgCount('Reference.remove', 0, 1, arguments.length);
+        require$$2$3.validateCallback('Reference.remove', 'onComplete', onComplete, true);
         const result = remove_1(this._delegate);
         if (onComplete) {
             result.then(() => onComplete(null), error => onComplete(error));
@@ -18018,9 +19618,9 @@ class Reference extends Query {
         return result;
     }
     transaction(transactionUpdate, onComplete, applyLocally) {
-        require$$1$3.validateArgCount('Reference.transaction', 1, 3, arguments.length);
-        require$$1$3.validateCallback('Reference.transaction', 'transactionUpdate', transactionUpdate, false);
-        require$$1$3.validateCallback('Reference.transaction', 'onComplete', onComplete, true);
+        require$$2$3.validateArgCount('Reference.transaction', 1, 3, arguments.length);
+        require$$2$3.validateCallback('Reference.transaction', 'transactionUpdate', transactionUpdate, false);
+        require$$2$3.validateCallback('Reference.transaction', 'onComplete', onComplete, true);
         validateBoolean('Reference.transaction', 'applyLocally', applyLocally);
         const result = runTransaction_1(this._delegate, transactionUpdate, {
             applyLocally
@@ -18031,8 +19631,8 @@ class Reference extends Query {
         return result;
     }
     setPriority(priority, onComplete) {
-        require$$1$3.validateArgCount('Reference.setPriority', 1, 2, arguments.length);
-        require$$1$3.validateCallback('Reference.setPriority', 'onComplete', onComplete, true);
+        require$$2$3.validateArgCount('Reference.setPriority', 1, 2, arguments.length);
+        require$$2$3.validateCallback('Reference.setPriority', 'onComplete', onComplete, true);
         const result = setPriority_1(this._delegate, priority);
         if (onComplete) {
             result.then(() => onComplete(null), error => onComplete(error));
@@ -18040,8 +19640,8 @@ class Reference extends Query {
         return result;
     }
     push(value, onComplete) {
-        require$$1$3.validateArgCount('Reference.push', 0, 2, arguments.length);
-        require$$1$3.validateCallback('Reference.push', 'onComplete', onComplete, true);
+        require$$2$3.validateArgCount('Reference.push', 0, 2, arguments.length);
+        require$$2$3.validateCallback('Reference.push', 'onComplete', onComplete, true);
         const expPromise = push_1(this._delegate, value);
         const promise = expPromise.then(expRef => new Reference(this.database, expRef));
         if (onComplete) {
@@ -18113,7 +19713,7 @@ class Database {
         connectDatabaseEmulator_1(this._delegate, host, port, options);
     }
     ref(path) {
-        require$$1$3.validateArgCount('database.ref', 0, 1, arguments.length);
+        require$$2$3.validateArgCount('database.ref', 0, 1, arguments.length);
         if (path instanceof Reference) {
             const childRef = refFromURL_1(this._delegate, path.toString());
             return new Reference(this, childRef);
@@ -18131,17 +19731,17 @@ class Database {
      */
     refFromURL(url) {
         const apiName = 'database.refFromURL';
-        require$$1$3.validateArgCount(apiName, 1, 1, arguments.length);
+        require$$2$3.validateArgCount(apiName, 1, 1, arguments.length);
         const childRef = refFromURL_1(this._delegate, url);
         return new Reference(this, childRef);
     }
     // Make individual repo go offline.
     goOffline() {
-        require$$1$3.validateArgCount('database.goOffline', 0, 0, arguments.length);
+        require$$2$3.validateArgCount('database.goOffline', 0, 0, arguments.length);
         return goOffline_1(this._delegate);
     }
     goOnline() {
-        require$$1$3.validateArgCount('database.goOnline', 0, 0, arguments.length);
+        require$$2$3.validateArgCount('database.goOnline', 0, 0, arguments.length);
         return goOnline_1(this._delegate);
     }
 }
@@ -18161,17 +19761,17 @@ Database.ServerValue = {
  */
 function initStandalone$1({ app, url, version, customAuthImpl, customAppCheckImpl, namespace, nodeAdmin = false }) {
     _setSDKVersion(version);
-    const container = new require$$4.ComponentContainer('database-standalone');
+    const container = new require$$0$2.ComponentContainer('database-standalone');
     /**
      * ComponentContainer('database-standalone') is just a placeholder that doesn't perform
      * any actual function.
      */
-    const authProvider = new require$$4.Provider('auth-internal', container);
-    authProvider.setComponent(new require$$4.Component('auth-internal', () => customAuthImpl, "PRIVATE" /* ComponentType.PRIVATE */));
+    const authProvider = new require$$0$2.Provider('auth-internal', container);
+    authProvider.setComponent(new require$$0$2.Component('auth-internal', () => customAuthImpl, "PRIVATE" /* ComponentType.PRIVATE */));
     let appCheckProvider = undefined;
     if (customAppCheckImpl) {
-        appCheckProvider = new require$$4.Provider('app-check-internal', container);
-        appCheckProvider.setComponent(new require$$4.Component('app-check-internal', () => customAppCheckImpl, "PRIVATE" /* ComponentType.PRIVATE */));
+        appCheckProvider = new require$$0$2.Provider('app-check-internal', container);
+        appCheckProvider.setComponent(new require$$0$2.Component('app-check-internal', () => customAppCheckImpl, "PRIVATE" /* ComponentType.PRIVATE */));
     }
     return {
         instance: new Database(_repoManagerDatabaseFromApp(app, authProvider, appCheckProvider, url, nodeAdmin), app),
@@ -18180,8 +19780,8 @@ function initStandalone$1({ app, url, version, customAuthImpl, customAppCheckImp
 }
 
 var INTERNAL = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  initStandalone: initStandalone$1
+	__proto__: null,
+	initStandalone: initStandalone$1
 });
 
 /**
@@ -18211,7 +19811,7 @@ const ServerValue = Database.ServerValue;
  * @param nodeAdmin - true if the SDK is being initialized from Firebase Admin.
  */
 function initStandalone(app, url, version, nodeAdmin = true) {
-    require$$1$3.CONSTANTS.NODE_ADMIN = nodeAdmin;
+    require$$2$3.CONSTANTS.NODE_ADMIN = nodeAdmin;
     return initStandalone$1({
         app,
         url,