{
  "version": 3,
  "sources": ["ssg:https://www.gstatic.com/firebasejs/11.5.0/firebase-app.js"],
  "sourcesContent": ["/**\n * @license\n * Copyright 2025 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// This value is retrieved and hardcoded by the NPM postinstall script\nconst getDefaultsFromPostinstall = () => undefined;\n\n/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nconst stringToByteArray$1 = function (str) {\n    // TODO(user): Use native implementations if/when available\n    const out = [];\n    let p = 0;\n    for (let i = 0; i < str.length; i++) {\n        let c = str.charCodeAt(i);\n        if (c < 128) {\n            out[p++] = c;\n        }\n        else if (c < 2048) {\n            out[p++] = (c >> 6) | 192;\n            out[p++] = (c & 63) | 128;\n        }\n        else if ((c & 0xfc00) === 0xd800 &&\n            i + 1 < str.length &&\n            (str.charCodeAt(i + 1) & 0xfc00) === 0xdc00) {\n            // Surrogate Pair\n            c = 0x10000 + ((c & 0x03ff) << 10) + (str.charCodeAt(++i) & 0x03ff);\n            out[p++] = (c >> 18) | 240;\n            out[p++] = ((c >> 12) & 63) | 128;\n            out[p++] = ((c >> 6) & 63) | 128;\n            out[p++] = (c & 63) | 128;\n        }\n        else {\n            out[p++] = (c >> 12) | 224;\n            out[p++] = ((c >> 6) & 63) | 128;\n            out[p++] = (c & 63) | 128;\n        }\n    }\n    return out;\n};\n/**\n * Turns an array of numbers into the string given by the concatenation of the\n * characters to which the numbers correspond.\n * @param bytes Array of numbers representing characters.\n * @return Stringification of the array.\n */\nconst byteArrayToString = function (bytes) {\n    // TODO(user): Use native implementations if/when available\n    const out = [];\n    let pos = 0, c = 0;\n    while (pos < bytes.length) {\n        const c1 = bytes[pos++];\n        if (c1 < 128) {\n            out[c++] = String.fromCharCode(c1);\n        }\n        else if (c1 > 191 && c1 < 224) {\n            const c2 = bytes[pos++];\n            out[c++] = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));\n        }\n        else if (c1 > 239 && c1 < 365) {\n            // Surrogate Pair\n            const c2 = bytes[pos++];\n            const c3 = bytes[pos++];\n            const c4 = bytes[pos++];\n            const u = (((c1 & 7) << 18) | ((c2 & 63) << 12) | ((c3 & 63) << 6) | (c4 & 63)) -\n                0x10000;\n            out[c++] = String.fromCharCode(0xd800 + (u >> 10));\n            out[c++] = String.fromCharCode(0xdc00 + (u & 1023));\n        }\n        else {\n            const c2 = bytes[pos++];\n            const c3 = bytes[pos++];\n            out[c++] = String.fromCharCode(((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));\n        }\n    }\n    return out.join('');\n};\n// We define it as an object literal instead of a class because a class compiled down to es5 can't\n// be treeshaked. https://github.com/rollup/rollup/issues/1691\n// Static lookup maps, lazily populated by init_()\n// TODO(dlarocque): Define this as a class, since we no longer target ES5.\nconst base64 = {\n    /**\n     * Maps bytes to characters.\n     */\n    byteToCharMap_: null,\n    /**\n     * Maps characters to bytes.\n     */\n    charToByteMap_: null,\n    /**\n     * Maps bytes to websafe characters.\n     * @private\n     */\n    byteToCharMapWebSafe_: null,\n    /**\n     * Maps websafe characters to bytes.\n     * @private\n     */\n    charToByteMapWebSafe_: null,\n    /**\n     * Our default alphabet, shared between\n     * ENCODED_VALS and ENCODED_VALS_WEBSAFE\n     */\n    ENCODED_VALS_BASE: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + 'abcdefghijklmnopqrstuvwxyz' + '0123456789',\n    /**\n     * Our default alphabet. Value 64 (=) is special; it means \"nothing.\"\n     */\n    get ENCODED_VALS() {\n        return this.ENCODED_VALS_BASE + '+/=';\n    },\n    /**\n     * Our websafe alphabet.\n     */\n    get ENCODED_VALS_WEBSAFE() {\n        return this.ENCODED_VALS_BASE + '-_.';\n    },\n    /**\n     * Whether this browser supports the atob and btoa functions. This extension\n     * started at Mozilla but is now implemented by many browsers. We use the\n     * ASSUME_* variables to avoid pulling in the full useragent detection library\n     * but still allowing the standard per-browser compilations.\n     *\n     */\n    HAS_NATIVE_SUPPORT: typeof atob === 'function',\n    /**\n     * Base64-encode an array of bytes.\n     *\n     * @param input An array of bytes (numbers with\n     *     value in [0, 255]) to encode.\n     * @param webSafe Boolean indicating we should use the\n     *     alternative alphabet.\n     * @return The base64 encoded string.\n     */\n    encodeByteArray(input, webSafe) {\n        if (!Array.isArray(input)) {\n            throw Error('encodeByteArray takes an array as a parameter');\n        }\n        this.init_();\n        const byteToCharMap = webSafe\n            ? this.byteToCharMapWebSafe_\n            : this.byteToCharMap_;\n        const output = [];\n        for (let i = 0; i < input.length; i += 3) {\n            const byte1 = input[i];\n            const haveByte2 = i + 1 < input.length;\n            const byte2 = haveByte2 ? input[i + 1] : 0;\n            const haveByte3 = i + 2 < input.length;\n            const byte3 = haveByte3 ? input[i + 2] : 0;\n            const outByte1 = byte1 >> 2;\n            const outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);\n            let outByte3 = ((byte2 & 0x0f) << 2) | (byte3 >> 6);\n            let outByte4 = byte3 & 0x3f;\n            if (!haveByte3) {\n                outByte4 = 64;\n                if (!haveByte2) {\n                    outByte3 = 64;\n                }\n            }\n            output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);\n        }\n        return output.join('');\n    },\n    /**\n     * Base64-encode a string.\n     *\n     * @param input A string to encode.\n     * @param webSafe If true, we should use the\n     *     alternative alphabet.\n     * @return The base64 encoded string.\n     */\n    encodeString(input, webSafe) {\n        // Shortcut for Mozilla browsers that implement\n        // a native base64 encoder in the form of \"btoa/atob\"\n        if (this.HAS_NATIVE_SUPPORT && !webSafe) {\n            return btoa(input);\n        }\n        return this.encodeByteArray(stringToByteArray$1(input), webSafe);\n    },\n    /**\n     * Base64-decode a string.\n     *\n     * @param input to decode.\n     * @param webSafe True if we should use the\n     *     alternative alphabet.\n     * @return string representing the decoded value.\n     */\n    decodeString(input, webSafe) {\n        // Shortcut for Mozilla browsers that implement\n        // a native base64 encoder in the form of \"btoa/atob\"\n        if (this.HAS_NATIVE_SUPPORT && !webSafe) {\n            return atob(input);\n        }\n        return byteArrayToString(this.decodeStringToByteArray(input, webSafe));\n    },\n    /**\n     * Base64-decode a string.\n     *\n     * In base-64 decoding, groups of four characters are converted into three\n     * bytes.  If the encoder did not apply padding, the input length may not\n     * be a multiple of 4.\n     *\n     * In this case, the last group will have fewer than 4 characters, and\n     * padding will be inferred.  If the group has one or two characters, it decodes\n     * to one byte.  If the group has three characters, it decodes to two bytes.\n     *\n     * @param input Input to decode.\n     * @param webSafe True if we should use the web-safe alphabet.\n     * @return bytes representing the decoded value.\n     */\n    decodeStringToByteArray(input, webSafe) {\n        this.init_();\n        const charToByteMap = webSafe\n            ? this.charToByteMapWebSafe_\n            : this.charToByteMap_;\n        const output = [];\n        for (let i = 0; i < input.length;) {\n            const byte1 = charToByteMap[input.charAt(i++)];\n            const haveByte2 = i < input.length;\n            const byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;\n            ++i;\n            const haveByte3 = i < input.length;\n            const byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;\n            ++i;\n            const haveByte4 = i < input.length;\n            const byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;\n            ++i;\n            if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {\n                throw new DecodeBase64StringError();\n            }\n            const outByte1 = (byte1 << 2) | (byte2 >> 4);\n            output.push(outByte1);\n            if (byte3 !== 64) {\n                const outByte2 = ((byte2 << 4) & 0xf0) | (byte3 >> 2);\n                output.push(outByte2);\n                if (byte4 !== 64) {\n                    const outByte3 = ((byte3 << 6) & 0xc0) | byte4;\n                    output.push(outByte3);\n                }\n            }\n        }\n        return output;\n    },\n    /**\n     * Lazy static initialization function. Called before\n     * accessing any of the static map variables.\n     * @private\n     */\n    init_() {\n        if (!this.byteToCharMap_) {\n            this.byteToCharMap_ = {};\n            this.charToByteMap_ = {};\n            this.byteToCharMapWebSafe_ = {};\n            this.charToByteMapWebSafe_ = {};\n            // We want quick mappings back and forth, so we precompute two maps.\n            for (let i = 0; i < this.ENCODED_VALS.length; i++) {\n                this.byteToCharMap_[i] = this.ENCODED_VALS.charAt(i);\n                this.charToByteMap_[this.byteToCharMap_[i]] = i;\n                this.byteToCharMapWebSafe_[i] = this.ENCODED_VALS_WEBSAFE.charAt(i);\n                this.charToByteMapWebSafe_[this.byteToCharMapWebSafe_[i]] = i;\n                // Be forgiving when decoding and correctly decode both encodings.\n                if (i >= this.ENCODED_VALS_BASE.length) {\n                    this.charToByteMap_[this.ENCODED_VALS_WEBSAFE.charAt(i)] = i;\n                    this.charToByteMapWebSafe_[this.ENCODED_VALS.charAt(i)] = i;\n                }\n            }\n        }\n    }\n};\n/**\n * An error encountered while decoding base64 string.\n */\nclass DecodeBase64StringError extends Error {\n    constructor() {\n        super(...arguments);\n        this.name = 'DecodeBase64StringError';\n    }\n}\n/**\n * URL-safe base64 encoding\n */\nconst base64Encode = function (str) {\n    const utf8Bytes = stringToByteArray$1(str);\n    return base64.encodeByteArray(utf8Bytes, true);\n};\n/**\n * URL-safe base64 encoding (without \".\" padding in the end).\n * e.g. Used in JSON Web Token (JWT) parts.\n */\nconst base64urlEncodeWithoutPadding = function (str) {\n    // Use base64url encoding and remove padding in the end (dot characters).\n    return base64Encode(str).replace(/\\./g, '');\n};\n/**\n * URL-safe base64 decoding\n *\n * NOTE: DO NOT use the global atob() function - it does NOT support the\n * base64Url variant encoding.\n *\n * @param str To be decoded\n * @return Decoded result, if possible\n */\nconst base64Decode = function (str) {\n    try {\n        return base64.decodeString(str, true);\n    }\n    catch (e) {\n        console.error('base64Decode failed: ', e);\n    }\n    return null;\n};\n/**\n * @license\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * Polyfill for `globalThis` object.\n * @returns the `globalThis` object for the given environment.\n * @public\n */\nfunction getGlobal() {\n    if (typeof self !== 'undefined') {\n        return self;\n    }\n    if (typeof window !== 'undefined') {\n        return window;\n    }\n    if (typeof global !== 'undefined') {\n        return global;\n    }\n    throw new Error('Unable to locate global object.');\n}\n/**\n * @license\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nconst getDefaultsFromGlobal = () => getGlobal().__FIREBASE_DEFAULTS__;\n/**\n * Attempt to read defaults from a JSON string provided to\n * process(.)env(.)__FIREBASE_DEFAULTS__ or a JSON file whose path is in\n * process(.)env(.)__FIREBASE_DEFAULTS_PATH__\n * The dots are in parens because certain compilers (Vite?) cannot\n * handle seeing that variable in comments.\n * See https://github.com/firebase/firebase-js-sdk/issues/6838\n */\nconst getDefaultsFromEnvVariable = () => {\n    if (typeof process === 'undefined' || typeof process.env === 'undefined') {\n        return;\n    }\n    const defaultsJsonString = process.env.__FIREBASE_DEFAULTS__;\n    if (defaultsJsonString) {\n        return JSON.parse(defaultsJsonString);\n    }\n};\nconst getDefaultsFromCookie = () => {\n    if (typeof document === 'undefined') {\n        return;\n    }\n    let match;\n    try {\n        match = document.cookie.match(/__FIREBASE_DEFAULTS__=([^;]+)/);\n    }\n    catch (e) {\n        // Some environments such as Angular Universal SSR have a\n        // `document` object but error on accessing `document.cookie`.\n        return;\n    }\n    const decoded = match && base64Decode(match[1]);\n    return decoded && JSON.parse(decoded);\n};\n/**\n * Get the __FIREBASE_DEFAULTS__ object. It checks in order:\n * (1) if such an object exists as a property of `globalThis`\n * (2) if such an object was provided on a shell environment variable\n * (3) if such an object exists in a cookie\n * @public\n */\nconst getDefaults = () => {\n    try {\n        return (getDefaultsFromPostinstall() ||\n            getDefaultsFromGlobal() ||\n            getDefaultsFromEnvVariable() ||\n            getDefaultsFromCookie());\n    }\n    catch (e) {\n        /**\n         * Catch-all for being unable to get __FIREBASE_DEFAULTS__ due\n         * to any environment case we have not accounted for. Log to\n         * info instead of swallowing so we can find these unknown cases\n         * and add paths for them if needed.\n         */\n        console.info(`Unable to get __FIREBASE_DEFAULTS__ due to: ${e}`);\n        return;\n    }\n};\n/**\n * Returns Firebase app config stored in the __FIREBASE_DEFAULTS__ object.\n * @public\n */\nconst getDefaultAppConfig = () => { var _a; return (_a = getDefaults()) === null || _a === void 0 ? void 0 : _a.config; };\n/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nclass Deferred {\n    constructor() {\n        this.reject = () => { };\n        this.resolve = () => { };\n        this.promise = new Promise((resolve, reject) => {\n            this.resolve = resolve;\n            this.reject = reject;\n        });\n    }\n    /**\n     * Our API internals are not promisified and cannot because our callback APIs have subtle expectations around\n     * invoking promises inline, which Promises are forbidden to do. This method accepts an optional node-style callback\n     * and returns a node-style callback which will resolve or reject the Deferred's promise.\n     */\n    wrapCallback(callback) {\n        return (error, value) => {\n            if (error) {\n                this.reject(error);\n            }\n            else {\n                this.resolve(value);\n            }\n            if (typeof callback === 'function') {\n                // Attaching noop handler just in case developer wasn't expecting\n                // promises\n                this.promise.catch(() => { });\n                // Some of our callbacks don't expect a value and our own tests\n                // assert that the parameter length is 1\n                if (callback.length === 1) {\n                    callback(error);\n                }\n                else {\n                    callback(error, value);\n                }\n            }\n        };\n    }\n}\n/**\n * Detect Browser Environment.\n * Note: This will return true for certain test frameworks that are incompletely\n * mimicking a browser, and should not lead to assuming all browser APIs are\n * available.\n */\nfunction isBrowser() {\n    return typeof window !== 'undefined' || isWebWorker();\n}\n/**\n * Detect Web Worker context.\n */\nfunction isWebWorker() {\n    return (typeof WorkerGlobalScope !== 'undefined' &&\n        typeof self !== 'undefined' &&\n        self instanceof WorkerGlobalScope);\n}\n/**\n * This method checks if indexedDB is supported by current browser/service worker context\n * @return true if indexedDB is supported by current browser/service worker context\n */\nfunction isIndexedDBAvailable() {\n    try {\n        return typeof indexedDB === 'object';\n    }\n    catch (e) {\n        return false;\n    }\n}\n/**\n * This method validates browser/sw context for indexedDB by opening a dummy indexedDB database and reject\n * if errors occur during the database open operation.\n *\n * @throws exception if current browser/sw context can't run idb.open (ex: Safari iframe, Firefox\n * private browsing)\n */\nfunction validateIndexedDBOpenable() {\n    return new Promise((resolve, reject) => {\n        try {\n            let preExist = true;\n            const DB_CHECK_NAME = 'validate-browser-context-for-indexeddb-analytics-module';\n            const request = self.indexedDB.open(DB_CHECK_NAME);\n            request.onsuccess = () => {\n                request.result.close();\n                // delete database only when it doesn't pre-exist\n                if (!preExist) {\n                    self.indexedDB.deleteDatabase(DB_CHECK_NAME);\n                }\n                resolve(true);\n            };\n            request.onupgradeneeded = () => {\n                preExist = false;\n            };\n            request.onerror = () => {\n                var _a;\n                reject(((_a = request.error) === null || _a === void 0 ? void 0 : _a.message) || '');\n            };\n        }\n        catch (error) {\n            reject(error);\n        }\n    });\n}\n/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * @fileoverview Standardized Firebase Error.\n *\n * Usage:\n *\n *   // TypeScript string literals for type-safe codes\n *   type Err =\n *     'unknown' |\n *     'object-not-found'\n *     ;\n *\n *   // Closure enum for type-safe error codes\n *   // at-enum {string}\n *   var Err = {\n *     UNKNOWN: 'unknown',\n *     OBJECT_NOT_FOUND: 'object-not-found',\n *   }\n *\n *   let errors: Map<Err, string> = {\n *     'generic-error': \"Unknown error\",\n *     'file-not-found': \"Could not find file: {$file}\",\n *   };\n *\n *   // Type-safe function - must pass a valid error code as param.\n *   let error = new ErrorFactory<Err>('service', 'Service', errors);\n *\n *   ...\n *   throw error.create(Err.GENERIC);\n *   ...\n *   throw error.create(Err.FILE_NOT_FOUND, {'file': fileName});\n *   ...\n *   // Service: Could not file file: foo.txt (service/file-not-found).\n *\n *   catch (e) {\n *     assert(e.message === \"Could not find file: foo.txt.\");\n *     if ((e as FirebaseError)?.code === 'service/file-not-found') {\n *       console.log(\"Could not read file: \" + e['file']);\n *     }\n *   }\n */\nconst ERROR_NAME = 'FirebaseError';\n// Based on code from:\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Custom_Error_Types\nclass FirebaseError extends Error {\n    constructor(\n    /** The error code for this error. */\n    code, message, \n    /** Custom data for this error. */\n    customData) {\n        super(message);\n        this.code = code;\n        this.customData = customData;\n        /** The custom name for all FirebaseErrors. */\n        this.name = ERROR_NAME;\n        // Fix For ES5\n        // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\n        // TODO(dlarocque): Replace this with `new.target`: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#support-for-newtarget\n        //                   which we can now use since we no longer target ES5.\n        Object.setPrototypeOf(this, FirebaseError.prototype);\n        // Maintains proper stack trace for where our error was thrown.\n        // Only available on V8.\n        if (Error.captureStackTrace) {\n            Error.captureStackTrace(this, ErrorFactory.prototype.create);\n        }\n    }\n}\nclass ErrorFactory {\n    constructor(service, serviceName, errors) {\n        this.service = service;\n        this.serviceName = serviceName;\n        this.errors = errors;\n    }\n    create(code, ...data) {\n        const customData = data[0] || {};\n        const fullCode = `${this.service}/${code}`;\n        const template = this.errors[code];\n        const message = template ? replaceTemplate(template, customData) : 'Error';\n        // Service Name: Error message (service/code).\n        const fullMessage = `${this.serviceName}: ${message} (${fullCode}).`;\n        const error = new FirebaseError(fullCode, fullMessage, customData);\n        return error;\n    }\n}\nfunction replaceTemplate(template, data) {\n    return template.replace(PATTERN, (_, key) => {\n        const value = data[key];\n        return value != null ? String(value) : `<${key}?>`;\n    });\n}\nconst PATTERN = /\\{\\$([^}]+)}/g;\n/**\n * Deep equal two objects. Support Arrays and Objects.\n */\nfunction deepEqual(a, b) {\n    if (a === b) {\n        return true;\n    }\n    const aKeys = Object.keys(a);\n    const bKeys = Object.keys(b);\n    for (const k of aKeys) {\n        if (!bKeys.includes(k)) {\n            return false;\n        }\n        const aProp = a[k];\n        const bProp = b[k];\n        if (isObject(aProp) && isObject(bProp)) {\n            if (!deepEqual(aProp, bProp)) {\n                return false;\n            }\n        }\n        else if (aProp !== bProp) {\n            return false;\n        }\n    }\n    for (const k of bKeys) {\n        if (!aKeys.includes(k)) {\n            return false;\n        }\n    }\n    return true;\n}\nfunction isObject(thing) {\n    return thing !== null && typeof thing === 'object';\n}\n\n/**\n * Component for service name T, e.g. `auth`, `auth-internal`\n */\nclass Component {\n    /**\n     *\n     * @param name The public service name, e.g. app, auth, firestore, database\n     * @param instanceFactory Service factory responsible for creating the public interface\n     * @param type whether the service provided by the component is public or private\n     */\n    constructor(name, instanceFactory, type) {\n        this.name = name;\n        this.instanceFactory = instanceFactory;\n        this.type = type;\n        this.multipleInstances = false;\n        /**\n         * Properties to be added to the service namespace\n         */\n        this.serviceProps = {};\n        this.instantiationMode = \"LAZY\" /* InstantiationMode.LAZY */;\n        this.onInstanceCreated = null;\n    }\n    setInstantiationMode(mode) {\n        this.instantiationMode = mode;\n        return this;\n    }\n    setMultipleInstances(multipleInstances) {\n        this.multipleInstances = multipleInstances;\n        return this;\n    }\n    setServiceProps(props) {\n        this.serviceProps = props;\n        return this;\n    }\n    setInstanceCreatedCallback(callback) {\n        this.onInstanceCreated = callback;\n        return this;\n    }\n}\n/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nconst DEFAULT_ENTRY_NAME$1 = '[DEFAULT]';\n/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * Provider for instance for service name T, e.g. 'auth', 'auth-internal'\n * NameServiceMapping[T] is an alias for the type of the instance\n */\nclass Provider {\n    constructor(name, container) {\n        this.name = name;\n        this.container = container;\n        this.component = null;\n        this.instances = new Map();\n        this.instancesDeferred = new Map();\n        this.instancesOptions = new Map();\n        this.onInitCallbacks = new Map();\n    }\n    /**\n     * @param identifier A provider can provide multiple instances of a service\n     * if this.component.multipleInstances is true.\n     */\n    get(identifier) {\n        // if multipleInstances is not supported, use the default name\n        const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);\n        if (!this.instancesDeferred.has(normalizedIdentifier)) {\n            const deferred = new Deferred();\n            this.instancesDeferred.set(normalizedIdentifier, deferred);\n            if (this.isInitialized(normalizedIdentifier) ||\n                this.shouldAutoInitialize()) {\n                // initialize the service if it can be auto-initialized\n                try {\n                    const instance = this.getOrInitializeService({\n                        instanceIdentifier: normalizedIdentifier\n                    });\n                    if (instance) {\n                        deferred.resolve(instance);\n                    }\n                }\n                catch (e) {\n                    // when the instance factory throws an exception during get(), it should not cause\n                    // a fatal error. We just return the unresolved promise in this case.\n                }\n            }\n        }\n        return this.instancesDeferred.get(normalizedIdentifier).promise;\n    }\n    getImmediate(options) {\n        var _a;\n        // if multipleInstances is not supported, use the default name\n        const normalizedIdentifier = this.normalizeInstanceIdentifier(options === null || options === void 0 ? void 0 : options.identifier);\n        const optional = (_a = options === null || options === void 0 ? void 0 : options.optional) !== null && _a !== void 0 ? _a : false;\n        if (this.isInitialized(normalizedIdentifier) ||\n            this.shouldAutoInitialize()) {\n            try {\n                return this.getOrInitializeService({\n                    instanceIdentifier: normalizedIdentifier\n                });\n            }\n            catch (e) {\n                if (optional) {\n                    return null;\n                }\n                else {\n                    throw e;\n                }\n            }\n        }\n        else {\n            // In case a component is not initialized and should/cannot be auto-initialized at the moment, return null if the optional flag is set, or throw\n            if (optional) {\n                return null;\n            }\n            else {\n                throw Error(`Service ${this.name} is not available`);\n            }\n        }\n    }\n    getComponent() {\n        return this.component;\n    }\n    setComponent(component) {\n        if (component.name !== this.name) {\n            throw Error(`Mismatching Component ${component.name} for Provider ${this.name}.`);\n        }\n        if (this.component) {\n            throw Error(`Component for ${this.name} has already been provided`);\n        }\n        this.component = component;\n        // return early without attempting to initialize the component if the component requires explicit initialization (calling `Provider.initialize()`)\n        if (!this.shouldAutoInitialize()) {\n            return;\n        }\n        // if the service is eager, initialize the default instance\n        if (isComponentEager(component)) {\n            try {\n                this.getOrInitializeService({ instanceIdentifier: DEFAULT_ENTRY_NAME$1 });\n            }\n            catch (e) {\n                // when the instance factory for an eager Component throws an exception during the eager\n                // initialization, it should not cause a fatal error.\n                // TODO: Investigate if we need to make it configurable, because some component may want to cause\n                // a fatal error in this case?\n            }\n        }\n        // Create service instances for the pending promises and resolve them\n        // NOTE: if this.multipleInstances is false, only the default instance will be created\n        // and all promises with resolve with it regardless of the identifier.\n        for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) {\n            const normalizedIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier);\n            try {\n                // `getOrInitializeService()` should always return a valid instance since a component is guaranteed. use ! to make typescript happy.\n                const instance = this.getOrInitializeService({\n                    instanceIdentifier: normalizedIdentifier\n                });\n                instanceDeferred.resolve(instance);\n            }\n            catch (e) {\n                // when the instance factory throws an exception, it should not cause\n                // a fatal error. We just leave the promise unresolved.\n            }\n        }\n    }\n    clearInstance(identifier = DEFAULT_ENTRY_NAME$1) {\n        this.instancesDeferred.delete(identifier);\n        this.instancesOptions.delete(identifier);\n        this.instances.delete(identifier);\n    }\n    // app.delete() will call this method on every provider to delete the services\n    // TODO: should we mark the provider as deleted?\n    async delete() {\n        const services = Array.from(this.instances.values());\n        await Promise.all([\n            ...services\n                .filter(service => 'INTERNAL' in service) // legacy services\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                .map(service => service.INTERNAL.delete()),\n            ...services\n                .filter(service => '_delete' in service) // modularized services\n                // eslint-disable-next-line @typescript-eslint/no-explicit-any\n                .map(service => service._delete())\n        ]);\n    }\n    isComponentSet() {\n        return this.component != null;\n    }\n    isInitialized(identifier = DEFAULT_ENTRY_NAME$1) {\n        return this.instances.has(identifier);\n    }\n    getOptions(identifier = DEFAULT_ENTRY_NAME$1) {\n        return this.instancesOptions.get(identifier) || {};\n    }\n    initialize(opts = {}) {\n        const { options = {} } = opts;\n        const normalizedIdentifier = this.normalizeInstanceIdentifier(opts.instanceIdentifier);\n        if (this.isInitialized(normalizedIdentifier)) {\n            throw Error(`${this.name}(${normalizedIdentifier}) has already been initialized`);\n        }\n        if (!this.isComponentSet()) {\n            throw Error(`Component ${this.name} has not been registered yet`);\n        }\n        const instance = this.getOrInitializeService({\n            instanceIdentifier: normalizedIdentifier,\n            options\n        });\n        // resolve any pending promise waiting for the service instance\n        for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) {\n            const normalizedDeferredIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier);\n            if (normalizedIdentifier === normalizedDeferredIdentifier) {\n                instanceDeferred.resolve(instance);\n            }\n        }\n        return instance;\n    }\n    /**\n     *\n     * @param callback - a function that will be invoked  after the provider has been initialized by calling provider.initialize().\n     * The function is invoked SYNCHRONOUSLY, so it should not execute any longrunning tasks in order to not block the program.\n     *\n     * @param identifier An optional instance identifier\n     * @returns a function to unregister the callback\n     */\n    onInit(callback, identifier) {\n        var _a;\n        const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);\n        const existingCallbacks = (_a = this.onInitCallbacks.get(normalizedIdentifier)) !== null && _a !== void 0 ? _a : new Set();\n        existingCallbacks.add(callback);\n        this.onInitCallbacks.set(normalizedIdentifier, existingCallbacks);\n        const existingInstance = this.instances.get(normalizedIdentifier);\n        if (existingInstance) {\n            callback(existingInstance, normalizedIdentifier);\n        }\n        return () => {\n            existingCallbacks.delete(callback);\n        };\n    }\n    /**\n     * Invoke onInit callbacks synchronously\n     * @param instance the service instance`\n     */\n    invokeOnInitCallbacks(instance, identifier) {\n        const callbacks = this.onInitCallbacks.get(identifier);\n        if (!callbacks) {\n            return;\n        }\n        for (const callback of callbacks) {\n            try {\n                callback(instance, identifier);\n            }\n            catch (_a) {\n                // ignore errors in the onInit callback\n            }\n        }\n    }\n    getOrInitializeService({ instanceIdentifier, options = {} }) {\n        let instance = this.instances.get(instanceIdentifier);\n        if (!instance && this.component) {\n            instance = this.component.instanceFactory(this.container, {\n                instanceIdentifier: normalizeIdentifierForFactory(instanceIdentifier),\n                options\n            });\n            this.instances.set(instanceIdentifier, instance);\n            this.instancesOptions.set(instanceIdentifier, options);\n            /**\n             * Invoke onInit listeners.\n             * Note this.component.onInstanceCreated is different, which is used by the component creator,\n             * while onInit listeners are registered by consumers of the provider.\n             */\n            this.invokeOnInitCallbacks(instance, instanceIdentifier);\n            /**\n             * Order is important\n             * onInstanceCreated() should be called after this.instances.set(instanceIdentifier, instance); which\n             * makes `isInitialized()` return true.\n             */\n            if (this.component.onInstanceCreated) {\n                try {\n                    this.component.onInstanceCreated(this.container, instanceIdentifier, instance);\n                }\n                catch (_a) {\n                    // ignore errors in the onInstanceCreatedCallback\n                }\n            }\n        }\n        return instance || null;\n    }\n    normalizeInstanceIdentifier(identifier = DEFAULT_ENTRY_NAME$1) {\n        if (this.component) {\n            return this.component.multipleInstances ? identifier : DEFAULT_ENTRY_NAME$1;\n        }\n        else {\n            return identifier; // assume multiple instances are supported before the component is provided.\n        }\n    }\n    shouldAutoInitialize() {\n        return (!!this.component &&\n            this.component.instantiationMode !== \"EXPLICIT\" /* InstantiationMode.EXPLICIT */);\n    }\n}\n// undefined should be passed to the service factory for the default instance\nfunction normalizeIdentifierForFactory(identifier) {\n    return identifier === DEFAULT_ENTRY_NAME$1 ? undefined : identifier;\n}\nfunction isComponentEager(component) {\n    return component.instantiationMode === \"EAGER\" /* InstantiationMode.EAGER */;\n}\n/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * ComponentContainer that provides Providers for service name T, e.g. `auth`, `auth-internal`\n */\nclass ComponentContainer {\n    constructor(name) {\n        this.name = name;\n        this.providers = new Map();\n    }\n    /**\n     *\n     * @param component Component being added\n     * @param overwrite When a component with the same name has already been registered,\n     * if overwrite is true: overwrite the existing component with the new component and create a new\n     * provider with the new component. It can be useful in tests where you want to use different mocks\n     * for different tests.\n     * if overwrite is false: throw an exception\n     */\n    addComponent(component) {\n        const provider = this.getProvider(component.name);\n        if (provider.isComponentSet()) {\n            throw new Error(`Component ${component.name} has already been registered with ${this.name}`);\n        }\n        provider.setComponent(component);\n    }\n    addOrOverwriteComponent(component) {\n        const provider = this.getProvider(component.name);\n        if (provider.isComponentSet()) {\n            // delete the existing provider from the container, so we can register the new component\n            this.providers.delete(component.name);\n        }\n        this.addComponent(component);\n    }\n    /**\n     * getProvider provides a type safe interface where it can only be called with a field name\n     * present in NameServiceMapping interface.\n     *\n     * Firebase SDKs providing services should extend NameServiceMapping interface to register\n     * themselves.\n     */\n    getProvider(name) {\n        if (this.providers.has(name)) {\n            return this.providers.get(name);\n        }\n        // create a Provider for a service that hasn't registered with Firebase\n        const provider = new Provider(name, this);\n        this.providers.set(name, provider);\n        return provider;\n    }\n    getProviders() {\n        return Array.from(this.providers.values());\n    }\n}\n\n/**\n * @license\n * Copyright 2017 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * A container for all of the Logger instances\n */\nconst instances = [];\n/**\n * The JS SDK supports 5 log levels and also allows a user the ability to\n * silence the logs altogether.\n *\n * The order is a follows:\n * DEBUG < VERBOSE < INFO < WARN < ERROR\n *\n * All of the log types above the current log level will be captured (i.e. if\n * you set the log level to `INFO`, errors will still be logged, but `DEBUG` and\n * `VERBOSE` logs will not)\n */\nvar LogLevel;\n(function (LogLevel) {\n    LogLevel[LogLevel[\"DEBUG\"] = 0] = \"DEBUG\";\n    LogLevel[LogLevel[\"VERBOSE\"] = 1] = \"VERBOSE\";\n    LogLevel[LogLevel[\"INFO\"] = 2] = \"INFO\";\n    LogLevel[LogLevel[\"WARN\"] = 3] = \"WARN\";\n    LogLevel[LogLevel[\"ERROR\"] = 4] = \"ERROR\";\n    LogLevel[LogLevel[\"SILENT\"] = 5] = \"SILENT\";\n})(LogLevel || (LogLevel = {}));\nconst levelStringToEnum = {\n    'debug': LogLevel.DEBUG,\n    'verbose': LogLevel.VERBOSE,\n    'info': LogLevel.INFO,\n    'warn': LogLevel.WARN,\n    'error': LogLevel.ERROR,\n    'silent': LogLevel.SILENT\n};\n/**\n * The default log level\n */\nconst defaultLogLevel = LogLevel.INFO;\n/**\n * By default, `console.debug` is not displayed in the developer console (in\n * chrome). To avoid forcing users to have to opt-in to these logs twice\n * (i.e. once for firebase, and once in the console), we are sending `DEBUG`\n * logs to the `console.log` function.\n */\nconst ConsoleMethod = {\n    [LogLevel.DEBUG]: 'log',\n    [LogLevel.VERBOSE]: 'log',\n    [LogLevel.INFO]: 'info',\n    [LogLevel.WARN]: 'warn',\n    [LogLevel.ERROR]: 'error'\n};\n/**\n * The default log handler will forward DEBUG, VERBOSE, INFO, WARN, and ERROR\n * messages on to their corresponding console counterparts (if the log method\n * is supported by the current log level)\n */\nconst defaultLogHandler = (instance, logType, ...args) => {\n    if (logType < instance.logLevel) {\n        return;\n    }\n    const now = new Date().toISOString();\n    const method = ConsoleMethod[logType];\n    if (method) {\n        console[method](`[${now}]  ${instance.name}:`, ...args);\n    }\n    else {\n        throw new Error(`Attempted to log a message with an invalid logType (value: ${logType})`);\n    }\n};\nclass Logger {\n    /**\n     * Gives you an instance of a Logger to capture messages according to\n     * Firebase's logging scheme.\n     *\n     * @param name The name that the logs will be associated with\n     */\n    constructor(name) {\n        this.name = name;\n        /**\n         * The log level of the given Logger instance.\n         */\n        this._logLevel = defaultLogLevel;\n        /**\n         * The main (internal) log handler for the Logger instance.\n         * Can be set to a new function in internal package code but not by user.\n         */\n        this._logHandler = defaultLogHandler;\n        /**\n         * The optional, additional, user-defined log handler for the Logger instance.\n         */\n        this._userLogHandler = null;\n        /**\n         * Capture the current instance for later use\n         */\n        instances.push(this);\n    }\n    get logLevel() {\n        return this._logLevel;\n    }\n    set logLevel(val) {\n        if (!(val in LogLevel)) {\n            throw new TypeError(`Invalid value \"${val}\" assigned to \\`logLevel\\``);\n        }\n        this._logLevel = val;\n    }\n    // Workaround for setter/getter having to be the same type.\n    setLogLevel(val) {\n        this._logLevel = typeof val === 'string' ? levelStringToEnum[val] : val;\n    }\n    get logHandler() {\n        return this._logHandler;\n    }\n    set logHandler(val) {\n        if (typeof val !== 'function') {\n            throw new TypeError('Value assigned to `logHandler` must be a function');\n        }\n        this._logHandler = val;\n    }\n    get userLogHandler() {\n        return this._userLogHandler;\n    }\n    set userLogHandler(val) {\n        this._userLogHandler = val;\n    }\n    /**\n     * The functions below are all based on the `console` interface\n     */\n    debug(...args) {\n        this._userLogHandler && this._userLogHandler(this, LogLevel.DEBUG, ...args);\n        this._logHandler(this, LogLevel.DEBUG, ...args);\n    }\n    log(...args) {\n        this._userLogHandler &&\n            this._userLogHandler(this, LogLevel.VERBOSE, ...args);\n        this._logHandler(this, LogLevel.VERBOSE, ...args);\n    }\n    info(...args) {\n        this._userLogHandler && this._userLogHandler(this, LogLevel.INFO, ...args);\n        this._logHandler(this, LogLevel.INFO, ...args);\n    }\n    warn(...args) {\n        this._userLogHandler && this._userLogHandler(this, LogLevel.WARN, ...args);\n        this._logHandler(this, LogLevel.WARN, ...args);\n    }\n    error(...args) {\n        this._userLogHandler && this._userLogHandler(this, LogLevel.ERROR, ...args);\n        this._logHandler(this, LogLevel.ERROR, ...args);\n    }\n}\nfunction setLogLevel$1(level) {\n    instances.forEach(inst => {\n        inst.setLogLevel(level);\n    });\n}\nfunction setUserLogHandler(logCallback, options) {\n    for (const instance of instances) {\n        let customLogLevel = null;\n        if (options && options.level) {\n            customLogLevel = levelStringToEnum[options.level];\n        }\n        if (logCallback === null) {\n            instance.userLogHandler = null;\n        }\n        else {\n            instance.userLogHandler = (instance, level, ...args) => {\n                const message = args\n                    .map(arg => {\n                    if (arg == null) {\n                        return null;\n                    }\n                    else if (typeof arg === 'string') {\n                        return arg;\n                    }\n                    else if (typeof arg === 'number' || typeof arg === 'boolean') {\n                        return arg.toString();\n                    }\n                    else if (arg instanceof Error) {\n                        return arg.message;\n                    }\n                    else {\n                        try {\n                            return JSON.stringify(arg);\n                        }\n                        catch (ignored) {\n                            return null;\n                        }\n                    }\n                })\n                    .filter(arg => arg)\n                    .join(' ');\n                if (level >= (customLogLevel !== null && customLogLevel !== void 0 ? customLogLevel : instance.logLevel)) {\n                    logCallback({\n                        level: LogLevel[level].toLowerCase(),\n                        message,\n                        args,\n                        type: instance.name\n                    });\n                }\n            };\n        }\n    }\n}\n\nconst instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);\nlet idbProxyableTypes;\nlet cursorAdvanceMethods;\n// This is a function to prevent it throwing up in node environments.\nfunction getIdbProxyableTypes() {\n    return (idbProxyableTypes ||\n        (idbProxyableTypes = [\n            IDBDatabase,\n            IDBObjectStore,\n            IDBIndex,\n            IDBCursor,\n            IDBTransaction,\n        ]));\n}\n// This is a function to prevent it throwing up in node environments.\nfunction getCursorAdvanceMethods() {\n    return (cursorAdvanceMethods ||\n        (cursorAdvanceMethods = [\n            IDBCursor.prototype.advance,\n            IDBCursor.prototype.continue,\n            IDBCursor.prototype.continuePrimaryKey,\n        ]));\n}\nconst cursorRequestMap = new WeakMap();\nconst transactionDoneMap = new WeakMap();\nconst transactionStoreNamesMap = new WeakMap();\nconst transformCache = new WeakMap();\nconst reverseTransformCache = new WeakMap();\nfunction promisifyRequest(request) {\n    const promise = new Promise((resolve, reject) => {\n        const unlisten = () => {\n            request.removeEventListener('success', success);\n            request.removeEventListener('error', error);\n        };\n        const success = () => {\n            resolve(wrap(request.result));\n            unlisten();\n        };\n        const error = () => {\n            reject(request.error);\n            unlisten();\n        };\n        request.addEventListener('success', success);\n        request.addEventListener('error', error);\n    });\n    promise\n        .then((value) => {\n        // Since cursoring reuses the IDBRequest (*sigh*), we cache it for later retrieval\n        // (see wrapFunction).\n        if (value instanceof IDBCursor) {\n            cursorRequestMap.set(value, request);\n        }\n        // Catching to avoid \"Uncaught Promise exceptions\"\n    })\n        .catch(() => { });\n    // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This\n    // is because we create many promises from a single IDBRequest.\n    reverseTransformCache.set(promise, request);\n    return promise;\n}\nfunction cacheDonePromiseForTransaction(tx) {\n    // Early bail if we've already created a done promise for this transaction.\n    if (transactionDoneMap.has(tx))\n        return;\n    const done = new Promise((resolve, reject) => {\n        const unlisten = () => {\n            tx.removeEventListener('complete', complete);\n            tx.removeEventListener('error', error);\n            tx.removeEventListener('abort', error);\n        };\n        const complete = () => {\n            resolve();\n            unlisten();\n        };\n        const error = () => {\n            reject(tx.error || new DOMException('AbortError', 'AbortError'));\n            unlisten();\n        };\n        tx.addEventListener('complete', complete);\n        tx.addEventListener('error', error);\n        tx.addEventListener('abort', error);\n    });\n    // Cache it for later retrieval.\n    transactionDoneMap.set(tx, done);\n}\nlet idbProxyTraps = {\n    get(target, prop, receiver) {\n        if (target instanceof IDBTransaction) {\n            // Special handling for transaction.done.\n            if (prop === 'done')\n                return transactionDoneMap.get(target);\n            // Polyfill for objectStoreNames because of Edge.\n            if (prop === 'objectStoreNames') {\n                return target.objectStoreNames || transactionStoreNamesMap.get(target);\n            }\n            // Make tx.store return the only store in the transaction, or undefined if there are many.\n            if (prop === 'store') {\n                return receiver.objectStoreNames[1]\n                    ? undefined\n                    : receiver.objectStore(receiver.objectStoreNames[0]);\n            }\n        }\n        // Else transform whatever we get back.\n        return wrap(target[prop]);\n    },\n    set(target, prop, value) {\n        target[prop] = value;\n        return true;\n    },\n    has(target, prop) {\n        if (target instanceof IDBTransaction &&\n            (prop === 'done' || prop === 'store')) {\n            return true;\n        }\n        return prop in target;\n    },\n};\nfunction replaceTraps(callback) {\n    idbProxyTraps = callback(idbProxyTraps);\n}\nfunction wrapFunction(func) {\n    // Due to expected object equality (which is enforced by the caching in `wrap`), we\n    // only create one new func per func.\n    // Edge doesn't support objectStoreNames (booo), so we polyfill it here.\n    if (func === IDBDatabase.prototype.transaction &&\n        !('objectStoreNames' in IDBTransaction.prototype)) {\n        return function (storeNames, ...args) {\n            const tx = func.call(unwrap(this), storeNames, ...args);\n            transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);\n            return wrap(tx);\n        };\n    }\n    // Cursor methods are special, as the behaviour is a little more different to standard IDB. In\n    // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the\n    // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense\n    // with real promises, so each advance methods returns a new promise for the cursor object, or\n    // undefined if the end of the cursor has been reached.\n    if (getCursorAdvanceMethods().includes(func)) {\n        return function (...args) {\n            // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use\n            // the original object.\n            func.apply(unwrap(this), args);\n            return wrap(cursorRequestMap.get(this));\n        };\n    }\n    return function (...args) {\n        // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use\n        // the original object.\n        return wrap(func.apply(unwrap(this), args));\n    };\n}\nfunction transformCachableValue(value) {\n    if (typeof value === 'function')\n        return wrapFunction(value);\n    // This doesn't return, it just creates a 'done' promise for the transaction,\n    // which is later returned for transaction.done (see idbObjectHandler).\n    if (value instanceof IDBTransaction)\n        cacheDonePromiseForTransaction(value);\n    if (instanceOfAny(value, getIdbProxyableTypes()))\n        return new Proxy(value, idbProxyTraps);\n    // Return the same value back if we're not going to transform it.\n    return value;\n}\nfunction wrap(value) {\n    // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because\n    // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.\n    if (value instanceof IDBRequest)\n        return promisifyRequest(value);\n    // If we've already transformed this value before, reuse the transformed value.\n    // This is faster, but it also provides object equality.\n    if (transformCache.has(value))\n        return transformCache.get(value);\n    const newValue = transformCachableValue(value);\n    // Not all types are transformed.\n    // These may be primitive types, so they can't be WeakMap keys.\n    if (newValue !== value) {\n        transformCache.set(value, newValue);\n        reverseTransformCache.set(newValue, value);\n    }\n    return newValue;\n}\nconst unwrap = (value) => reverseTransformCache.get(value);\n\n/**\n * Open a database.\n *\n * @param name Name of the database.\n * @param version Schema version.\n * @param callbacks Additional callbacks.\n */\nfunction openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {\n    const request = indexedDB.open(name, version);\n    const openPromise = wrap(request);\n    if (upgrade) {\n        request.addEventListener('upgradeneeded', (event) => {\n            upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);\n        });\n    }\n    if (blocked) {\n        request.addEventListener('blocked', (event) => blocked(\n        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405\n        event.oldVersion, event.newVersion, event));\n    }\n    openPromise\n        .then((db) => {\n        if (terminated)\n            db.addEventListener('close', () => terminated());\n        if (blocking) {\n            db.addEventListener('versionchange', (event) => blocking(event.oldVersion, event.newVersion, event));\n        }\n    })\n        .catch(() => { });\n    return openPromise;\n}\nconst readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];\nconst writeMethods = ['put', 'add', 'delete', 'clear'];\nconst cachedMethods = new Map();\nfunction getMethod(target, prop) {\n    if (!(target instanceof IDBDatabase &&\n        !(prop in target) &&\n        typeof prop === 'string')) {\n        return;\n    }\n    if (cachedMethods.get(prop))\n        return cachedMethods.get(prop);\n    const targetFuncName = prop.replace(/FromIndex$/, '');\n    const useIndex = prop !== targetFuncName;\n    const isWrite = writeMethods.includes(targetFuncName);\n    if (\n    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.\n    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) ||\n        !(isWrite || readMethods.includes(targetFuncName))) {\n        return;\n    }\n    const method = async function (storeName, ...args) {\n        // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(\n        const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');\n        let target = tx.store;\n        if (useIndex)\n            target = target.index(args.shift());\n        // Must reject if op rejects.\n        // If it's a write operation, must reject if tx.done rejects.\n        // Must reject with op rejection first.\n        // Must resolve with op value.\n        // Must handle both promises (no unhandled rejections)\n        return (await Promise.all([\n            target[targetFuncName](...args),\n            isWrite && tx.done,\n        ]))[0];\n    };\n    cachedMethods.set(prop, method);\n    return method;\n}\nreplaceTraps((oldTraps) => (Object.assign(Object.assign({}, oldTraps), { get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver), has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop) })));\n\n/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nclass PlatformLoggerServiceImpl {\n    constructor(container) {\n        this.container = container;\n    }\n    // In initial implementation, this will be called by installations on\n    // auth token refresh, and installations will send this string.\n    getPlatformInfoString() {\n        const providers = this.container.getProviders();\n        // Loop through providers and get library/version pairs from any that are\n        // version components.\n        return providers\n            .map(provider => {\n            if (isVersionServiceProvider(provider)) {\n                const service = provider.getImmediate();\n                return `${service.library}/${service.version}`;\n            }\n            else {\n                return null;\n            }\n        })\n            .filter(logString => logString)\n            .join(' ');\n    }\n}\n/**\n *\n * @param provider check if this provider provides a VersionService\n *\n * NOTE: Using Provider<'app-version'> is a hack to indicate that the provider\n * provides VersionService. The provider is not necessarily a 'app-version'\n * provider.\n */\nfunction isVersionServiceProvider(provider) {\n    const component = provider.getComponent();\n    return (component === null || component === void 0 ? void 0 : component.type) === \"VERSION\" /* ComponentType.VERSION */;\n}\nconst name$q = \"https://www.gstatic.com/firebasejs/11.5.0/firebase-app.js\";\nconst version$1 = \"0.11.3\";\n/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nconst logger = new Logger('https://www.gstatic.com/firebasejs/11.5.0/firebase-app.js');\nconst name$p = \"@firebase/app-compat\";\nconst name$o = \"@firebase/analytics-compat\";\nconst name$n = \"@firebase/analytics\";\nconst name$m = \"@firebase/app-check-compat\";\nconst name$l = \"@firebase/app-check\";\nconst name$k = \"@firebase/auth\";\nconst name$j = \"@firebase/auth-compat\";\nconst name$i = \"@firebase/database\";\nconst name$h = \"@firebase/data-connect\";\nconst name$g = \"@firebase/database-compat\";\nconst name$f = \"@firebase/functions\";\nconst name$e = \"@firebase/functions-compat\";\nconst name$d = \"@firebase/installations\";\nconst name$c = \"@firebase/installations-compat\";\nconst name$b = \"@firebase/messaging\";\nconst name$a = \"@firebase/messaging-compat\";\nconst name$9 = \"@firebase/performance\";\nconst name$8 = \"@firebase/performance-compat\";\nconst name$7 = \"@firebase/remote-config\";\nconst name$6 = \"@firebase/remote-config-compat\";\nconst name$5 = \"@firebase/storage\";\nconst name$4 = \"@firebase/storage-compat\";\nconst name$3 = \"@firebase/firestore\";\nconst name$2 = \"@firebase/vertexai\";\nconst name$1 = \"@firebase/firestore-compat\";\nconst name$r = \"firebase\";\nconst version$2 = \"11.5.0\";\n/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * The default app name\n *\n * @internal\n */\nconst DEFAULT_ENTRY_NAME = '[DEFAULT]';\nconst PLATFORM_LOG_STRING = {\n    [name$q]: 'fire-core',\n    [name$p]: 'fire-core-compat',\n    [name$n]: 'fire-analytics',\n    [name$o]: 'fire-analytics-compat',\n    [name$l]: 'fire-app-check',\n    [name$m]: 'fire-app-check-compat',\n    [name$k]: 'fire-auth',\n    [name$j]: 'fire-auth-compat',\n    [name$i]: 'fire-rtdb',\n    [name$h]: 'fire-data-connect',\n    [name$g]: 'fire-rtdb-compat',\n    [name$f]: 'fire-fn',\n    [name$e]: 'fire-fn-compat',\n    [name$d]: 'fire-iid',\n    [name$c]: 'fire-iid-compat',\n    [name$b]: 'fire-fcm',\n    [name$a]: 'fire-fcm-compat',\n    [name$9]: 'fire-perf',\n    [name$8]: 'fire-perf-compat',\n    [name$7]: 'fire-rc',\n    [name$6]: 'fire-rc-compat',\n    [name$5]: 'fire-gcs',\n    [name$4]: 'fire-gcs-compat',\n    [name$3]: 'fire-fst',\n    [name$1]: 'fire-fst-compat',\n    [name$2]: 'fire-vertex',\n    'fire-js': 'fire-js', // Platform identifier for JS SDK.\n    [name$r]: 'fire-js-all'\n};\n/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * @internal\n */\nconst _apps = new Map();\n/**\n * @internal\n */\nconst _serverApps = new Map();\n/**\n * Registered components.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst _components = new Map();\n/**\n * @param component - the component being added to this app's container\n *\n * @internal\n */\nfunction _addComponent(app, component) {\n    try {\n        app.container.addComponent(component);\n    }\n    catch (e) {\n        logger.debug(`Component ${component.name} failed to register with FirebaseApp ${app.name}`, e);\n    }\n}\n/**\n *\n * @internal\n */\nfunction _addOrOverwriteComponent(app, component) {\n    app.container.addOrOverwriteComponent(component);\n}\n/**\n *\n * @param component - the component to register\n * @returns whether or not the component is registered successfully\n *\n * @internal\n */\nfunction _registerComponent(component) {\n    const componentName = component.name;\n    if (_components.has(componentName)) {\n        logger.debug(`There were multiple attempts to register component ${componentName}.`);\n        return false;\n    }\n    _components.set(componentName, component);\n    // add the component to existing app instances\n    for (const app of _apps.values()) {\n        _addComponent(app, component);\n    }\n    for (const serverApp of _serverApps.values()) {\n        _addComponent(serverApp, component);\n    }\n    return true;\n}\n/**\n *\n * @param app - FirebaseApp instance\n * @param name - service name\n *\n * @returns the provider for the service with the matching name\n *\n * @internal\n */\nfunction _getProvider(app, name) {\n    const heartbeatController = app.container\n        .getProvider('heartbeat')\n        .getImmediate({ optional: true });\n    if (heartbeatController) {\n        void heartbeatController.triggerHeartbeat();\n    }\n    return app.container.getProvider(name);\n}\n/**\n *\n * @param app - FirebaseApp instance\n * @param name - service name\n * @param instanceIdentifier - service instance identifier in case the service supports multiple instances\n *\n * @internal\n */\nfunction _removeServiceInstance(app, name, instanceIdentifier = DEFAULT_ENTRY_NAME) {\n    _getProvider(app, name).clearInstance(instanceIdentifier);\n}\n/**\n *\n * @param obj - an object of type FirebaseApp or FirebaseOptions.\n *\n * @returns true if the provide object is of type FirebaseApp.\n *\n * @internal\n */\nfunction _isFirebaseApp(obj) {\n    return obj.options !== undefined;\n}\n/**\n *\n * @param obj - an object of type FirebaseApp.\n *\n * @returns true if the provided object is of type FirebaseServerAppImpl.\n *\n * @internal\n */\nfunction _isFirebaseServerApp(obj) {\n    if (obj === null || obj === undefined) {\n        return false;\n    }\n    return obj.settings !== undefined;\n}\n/**\n * Test only\n *\n * @internal\n */\nfunction _clearComponents() {\n    _components.clear();\n}\n/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nconst ERRORS = {\n    [\"no-app\" /* AppError.NO_APP */]: \"No Firebase App '{$appName}' has been created - \" +\n        'call initializeApp() first',\n    [\"bad-app-name\" /* AppError.BAD_APP_NAME */]: \"Illegal App name: '{$appName}'\",\n    [\"duplicate-app\" /* AppError.DUPLICATE_APP */]: \"Firebase App named '{$appName}' already exists with different options or config\",\n    [\"app-deleted\" /* AppError.APP_DELETED */]: \"Firebase App named '{$appName}' already deleted\",\n    [\"server-app-deleted\" /* AppError.SERVER_APP_DELETED */]: 'Firebase Server App has been deleted',\n    [\"no-options\" /* AppError.NO_OPTIONS */]: 'Need to provide options, when not being deployed to hosting via source.',\n    [\"invalid-app-argument\" /* AppError.INVALID_APP_ARGUMENT */]: 'firebase.{$appName}() takes either no argument or a ' +\n        'Firebase App instance.',\n    [\"invalid-log-argument\" /* AppError.INVALID_LOG_ARGUMENT */]: 'First argument to `onLog` must be null or a function.',\n    [\"idb-open\" /* AppError.IDB_OPEN */]: 'Error thrown when opening IndexedDB. Original error: {$originalErrorMessage}.',\n    [\"idb-get\" /* AppError.IDB_GET */]: 'Error thrown when reading from IndexedDB. Original error: {$originalErrorMessage}.',\n    [\"idb-set\" /* AppError.IDB_WRITE */]: 'Error thrown when writing to IndexedDB. Original error: {$originalErrorMessage}.',\n    [\"idb-delete\" /* AppError.IDB_DELETE */]: 'Error thrown when deleting from IndexedDB. Original error: {$originalErrorMessage}.',\n    [\"finalization-registry-not-supported\" /* AppError.FINALIZATION_REGISTRY_NOT_SUPPORTED */]: 'FirebaseServerApp deleteOnDeref field defined but the JS runtime does not support FinalizationRegistry.',\n    [\"invalid-server-app-environment\" /* AppError.INVALID_SERVER_APP_ENVIRONMENT */]: 'FirebaseServerApp is not for use in browser environments.'\n};\nconst ERROR_FACTORY = new ErrorFactory('app', 'Firebase', ERRORS);\n/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nclass FirebaseAppImpl {\n    constructor(options, config, container) {\n        this._isDeleted = false;\n        this._options = Object.assign({}, options);\n        this._config = Object.assign({}, config);\n        this._name = config.name;\n        this._automaticDataCollectionEnabled =\n            config.automaticDataCollectionEnabled;\n        this._container = container;\n        this.container.addComponent(new Component('app', () => this, \"PUBLIC\" /* ComponentType.PUBLIC */));\n    }\n    get automaticDataCollectionEnabled() {\n        this.checkDestroyed();\n        return this._automaticDataCollectionEnabled;\n    }\n    set automaticDataCollectionEnabled(val) {\n        this.checkDestroyed();\n        this._automaticDataCollectionEnabled = val;\n    }\n    get name() {\n        this.checkDestroyed();\n        return this._name;\n    }\n    get options() {\n        this.checkDestroyed();\n        return this._options;\n    }\n    get config() {\n        this.checkDestroyed();\n        return this._config;\n    }\n    get container() {\n        return this._container;\n    }\n    get isDeleted() {\n        return this._isDeleted;\n    }\n    set isDeleted(val) {\n        this._isDeleted = val;\n    }\n    /**\n     * This function will throw an Error if the App has already been deleted -\n     * use before performing API actions on the App.\n     */\n    checkDestroyed() {\n        if (this.isDeleted) {\n            throw ERROR_FACTORY.create(\"app-deleted\" /* AppError.APP_DELETED */, { appName: this._name });\n        }\n    }\n}\n/**\n * @license\n * Copyright 2023 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Parse the token and check to see if the `exp` claim is in the future.\n// Reports an error to the console if the token or claim could not be parsed, or if `exp` is in\n// the past.\nfunction validateTokenTTL(base64Token, tokenName) {\n    const secondPart = base64Decode(base64Token.split('.')[1]);\n    if (secondPart === null) {\n        console.error(`FirebaseServerApp ${tokenName} is invalid: second part could not be parsed.`);\n        return;\n    }\n    const expClaim = JSON.parse(secondPart).exp;\n    if (expClaim === undefined) {\n        console.error(`FirebaseServerApp ${tokenName} is invalid: expiration claim could not be parsed`);\n        return;\n    }\n    const exp = JSON.parse(secondPart).exp * 1000;\n    const now = new Date().getTime();\n    const diff = exp - now;\n    if (diff <= 0) {\n        console.error(`FirebaseServerApp ${tokenName} is invalid: the token has expired.`);\n    }\n}\nclass FirebaseServerAppImpl extends FirebaseAppImpl {\n    constructor(options, serverConfig, name, container) {\n        // Build configuration parameters for the FirebaseAppImpl base class.\n        const automaticDataCollectionEnabled = serverConfig.automaticDataCollectionEnabled !== undefined\n            ? serverConfig.automaticDataCollectionEnabled\n            : false;\n        // Create the FirebaseAppSettings object for the FirebaseAppImp constructor.\n        const config = {\n            name,\n            automaticDataCollectionEnabled\n        };\n        if (options.apiKey !== undefined) {\n            // Construct the parent FirebaseAppImp object.\n            super(options, config, container);\n        }\n        else {\n            const appImpl = options;\n            super(appImpl.options, config, container);\n        }\n        // Now construct the data for the FirebaseServerAppImpl.\n        this._serverConfig = Object.assign({ automaticDataCollectionEnabled }, serverConfig);\n        // Ensure that the current time is within the `authIdtoken` window of validity.\n        if (this._serverConfig.authIdToken) {\n            validateTokenTTL(this._serverConfig.authIdToken, 'authIdToken');\n        }\n        // Ensure that the current time is within the `appCheckToken` window of validity.\n        if (this._serverConfig.appCheckToken) {\n            validateTokenTTL(this._serverConfig.appCheckToken, 'appCheckToken');\n        }\n        this._finalizationRegistry = null;\n        if (typeof FinalizationRegistry !== 'undefined') {\n            this._finalizationRegistry = new FinalizationRegistry(() => {\n                this.automaticCleanup();\n            });\n        }\n        this._refCount = 0;\n        this.incRefCount(this._serverConfig.releaseOnDeref);\n        // Do not retain a hard reference to the dref object, otherwise the FinalizationRegistry\n        // will never trigger.\n        this._serverConfig.releaseOnDeref = undefined;\n        serverConfig.releaseOnDeref = undefined;\n        registerVersion(name$q, version$1, 'serverapp');\n    }\n    toJSON() {\n        return undefined;\n    }\n    get refCount() {\n        return this._refCount;\n    }\n    // Increment the reference count of this server app. If an object is provided, register it\n    // with the finalization registry.\n    incRefCount(obj) {\n        if (this.isDeleted) {\n            return;\n        }\n        this._refCount++;\n        if (obj !== undefined && this._finalizationRegistry !== null) {\n            this._finalizationRegistry.register(obj, this);\n        }\n    }\n    // Decrement the reference count.\n    decRefCount() {\n        if (this.isDeleted) {\n            return 0;\n        }\n        return --this._refCount;\n    }\n    // Invoked by the FinalizationRegistry callback to note that this app should go through its\n    // reference counts and delete itself if no reference count remain. The coordinating logic that\n    // handles this is in deleteApp(...).\n    automaticCleanup() {\n        void deleteApp(this);\n    }\n    get settings() {\n        this.checkDestroyed();\n        return this._serverConfig;\n    }\n    /**\n     * This function will throw an Error if the App has already been deleted -\n     * use before performing API actions on the App.\n     */\n    checkDestroyed() {\n        if (this.isDeleted) {\n            throw ERROR_FACTORY.create(\"server-app-deleted\" /* AppError.SERVER_APP_DELETED */);\n        }\n    }\n}\n/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * The current SDK version.\n *\n * @public\n */\nconst SDK_VERSION = version$2;\nfunction initializeApp(_options, rawConfig = {}) {\n    let options = _options;\n    if (typeof rawConfig !== 'object') {\n        const name = rawConfig;\n        rawConfig = { name };\n    }\n    const config = Object.assign({ name: DEFAULT_ENTRY_NAME, automaticDataCollectionEnabled: false }, rawConfig);\n    const name = config.name;\n    if (typeof name !== 'string' || !name) {\n        throw ERROR_FACTORY.create(\"bad-app-name\" /* AppError.BAD_APP_NAME */, {\n            appName: String(name)\n        });\n    }\n    options || (options = getDefaultAppConfig());\n    if (!options) {\n        throw ERROR_FACTORY.create(\"no-options\" /* AppError.NO_OPTIONS */);\n    }\n    const existingApp = _apps.get(name);\n    if (existingApp) {\n        // return the existing app if options and config deep equal the ones in the existing app.\n        if (deepEqual(options, existingApp.options) &&\n            deepEqual(config, existingApp.config)) {\n            return existingApp;\n        }\n        else {\n            throw ERROR_FACTORY.create(\"duplicate-app\" /* AppError.DUPLICATE_APP */, { appName: name });\n        }\n    }\n    const container = new ComponentContainer(name);\n    for (const component of _components.values()) {\n        container.addComponent(component);\n    }\n    const newApp = new FirebaseAppImpl(options, config, container);\n    _apps.set(name, newApp);\n    return newApp;\n}\nfunction initializeServerApp(_options, _serverAppConfig) {\n    if (isBrowser() && !isWebWorker()) {\n        // FirebaseServerApp isn't designed to be run in browsers.\n        throw ERROR_FACTORY.create(\"invalid-server-app-environment\" /* AppError.INVALID_SERVER_APP_ENVIRONMENT */);\n    }\n    if (_serverAppConfig.automaticDataCollectionEnabled === undefined) {\n        _serverAppConfig.automaticDataCollectionEnabled = false;\n    }\n    let appOptions;\n    if (_isFirebaseApp(_options)) {\n        appOptions = _options.options;\n    }\n    else {\n        appOptions = _options;\n    }\n    // Build an app name based on a hash of the configuration options.\n    const nameObj = Object.assign(Object.assign({}, _serverAppConfig), appOptions);\n    // However, Do not mangle the name based on releaseOnDeref, since it will vary between the\n    // construction of FirebaseServerApp instances. For example, if the object is the request headers.\n    if (nameObj.releaseOnDeref !== undefined) {\n        delete nameObj.releaseOnDeref;\n    }\n    const hashCode = (s) => {\n        return [...s].reduce((hash, c) => (Math.imul(31, hash) + c.charCodeAt(0)) | 0, 0);\n    };\n    if (_serverAppConfig.releaseOnDeref !== undefined) {\n        if (typeof FinalizationRegistry === 'undefined') {\n            throw ERROR_FACTORY.create(\"finalization-registry-not-supported\" /* AppError.FINALIZATION_REGISTRY_NOT_SUPPORTED */, {});\n        }\n    }\n    const nameString = '' + hashCode(JSON.stringify(nameObj));\n    const existingApp = _serverApps.get(nameString);\n    if (existingApp) {\n        existingApp.incRefCount(_serverAppConfig.releaseOnDeref);\n        return existingApp;\n    }\n    const container = new ComponentContainer(nameString);\n    for (const component of _components.values()) {\n        container.addComponent(component);\n    }\n    const newApp = new FirebaseServerAppImpl(appOptions, _serverAppConfig, nameString, container);\n    _serverApps.set(nameString, newApp);\n    return newApp;\n}\n/**\n * Retrieves a {@link @firebase/app#FirebaseApp} instance.\n *\n * When called with no arguments, the default app is returned. When an app name\n * is provided, the app corresponding to that name is returned.\n *\n * An exception is thrown if the app being retrieved has not yet been\n * initialized.\n *\n * @example\n * ```javascript\n * // Return the default app\n * const app = getApp();\n * ```\n *\n * @example\n * ```javascript\n * // Return a named app\n * const otherApp = getApp(\"otherApp\");\n * ```\n *\n * @param name - Optional name of the app to return. If no name is\n *   provided, the default is `\"[DEFAULT]\"`.\n *\n * @returns The app corresponding to the provided app name.\n *   If no app name is provided, the default app is returned.\n *\n * @public\n */\nfunction getApp(name = DEFAULT_ENTRY_NAME) {\n    const app = _apps.get(name);\n    if (!app && name === DEFAULT_ENTRY_NAME && getDefaultAppConfig()) {\n        return initializeApp();\n    }\n    if (!app) {\n        throw ERROR_FACTORY.create(\"no-app\" /* AppError.NO_APP */, { appName: name });\n    }\n    return app;\n}\n/**\n * A (read-only) array of all initialized apps.\n * @public\n */\nfunction getApps() {\n    return Array.from(_apps.values());\n}\n/**\n * Renders this app unusable and frees the resources of all associated\n * services.\n *\n * @example\n * ```javascript\n * deleteApp(app)\n *   .then(function() {\n *     console.log(\"App deleted successfully\");\n *   })\n *   .catch(function(error) {\n *     console.log(\"Error deleting app:\", error);\n *   });\n * ```\n *\n * @public\n */\nasync function deleteApp(app) {\n    let cleanupProviders = false;\n    const name = app.name;\n    if (_apps.has(name)) {\n        cleanupProviders = true;\n        _apps.delete(name);\n    }\n    else if (_serverApps.has(name)) {\n        const firebaseServerApp = app;\n        if (firebaseServerApp.decRefCount() <= 0) {\n            _serverApps.delete(name);\n            cleanupProviders = true;\n        }\n    }\n    if (cleanupProviders) {\n        await Promise.all(app.container\n            .getProviders()\n            .map(provider => provider.delete()));\n        app.isDeleted = true;\n    }\n}\n/**\n * Registers a library's name and version for platform logging purposes.\n * @param library - Name of 1p or 3p library (e.g. firestore, angularfire)\n * @param version - Current version of that library.\n * @param variant - Bundle variant, e.g., node, rn, etc.\n *\n * @public\n */\nfunction registerVersion(libraryKeyOrName, version, variant) {\n    var _a;\n    // TODO: We can use this check to whitelist strings when/if we set up\n    // a good whitelist system.\n    let library = (_a = PLATFORM_LOG_STRING[libraryKeyOrName]) !== null && _a !== void 0 ? _a : libraryKeyOrName;\n    if (variant) {\n        library += `-${variant}`;\n    }\n    const libraryMismatch = library.match(/\\s|\\//);\n    const versionMismatch = version.match(/\\s|\\//);\n    if (libraryMismatch || versionMismatch) {\n        const warning = [\n            `Unable to register library \"${library}\" with version \"${version}\":`\n        ];\n        if (libraryMismatch) {\n            warning.push(`library name \"${library}\" contains illegal characters (whitespace or \"/\")`);\n        }\n        if (libraryMismatch && versionMismatch) {\n            warning.push('and');\n        }\n        if (versionMismatch) {\n            warning.push(`version name \"${version}\" contains illegal characters (whitespace or \"/\")`);\n        }\n        logger.warn(warning.join(' '));\n        return;\n    }\n    _registerComponent(new Component(`${library}-version`, () => ({ library, version }), \"VERSION\" /* ComponentType.VERSION */));\n}\n/**\n * Sets log handler for all Firebase SDKs.\n * @param logCallback - An optional custom log handler that executes user code whenever\n * the Firebase SDK makes a logging call.\n *\n * @public\n */\nfunction onLog(logCallback, options) {\n    if (logCallback !== null && typeof logCallback !== 'function') {\n        throw ERROR_FACTORY.create(\"invalid-log-argument\" /* AppError.INVALID_LOG_ARGUMENT */);\n    }\n    setUserLogHandler(logCallback, options);\n}\n/**\n * Sets log level for all Firebase SDKs.\n *\n * All of the log types above the current log level are captured (i.e. if\n * you set the log level to `info`, errors are logged, but `debug` and\n * `verbose` logs are not).\n *\n * @public\n */\nfunction setLogLevel(logLevel) {\n    setLogLevel$1(logLevel);\n}\n/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nconst DB_NAME = 'firebase-heartbeat-database';\nconst DB_VERSION = 1;\nconst STORE_NAME = 'firebase-heartbeat-store';\nlet dbPromise = null;\nfunction getDbPromise() {\n    if (!dbPromise) {\n        dbPromise = openDB(DB_NAME, DB_VERSION, {\n            upgrade: (db, oldVersion) => {\n                // We don't use 'break' in this switch statement, the fall-through\n                // behavior is what we want, because if there are multiple versions between\n                // the old version and the current version, we want ALL the migrations\n                // that correspond to those versions to run, not only the last one.\n                // eslint-disable-next-line default-case\n                switch (oldVersion) {\n                    case 0:\n                        try {\n                            db.createObjectStore(STORE_NAME);\n                        }\n                        catch (e) {\n                            // Safari/iOS browsers throw occasional exceptions on\n                            // db.createObjectStore() that may be a bug. Avoid blocking\n                            // the rest of the app functionality.\n                            console.warn(e);\n                        }\n                }\n            }\n        }).catch(e => {\n            throw ERROR_FACTORY.create(\"idb-open\" /* AppError.IDB_OPEN */, {\n                originalErrorMessage: e.message\n            });\n        });\n    }\n    return dbPromise;\n}\nasync function readHeartbeatsFromIndexedDB(app) {\n    try {\n        const db = await getDbPromise();\n        const tx = db.transaction(STORE_NAME);\n        const result = await tx.objectStore(STORE_NAME).get(computeKey(app));\n        // We already have the value but tx.done can throw,\n        // so we need to await it here to catch errors\n        await tx.done;\n        return result;\n    }\n    catch (e) {\n        if (e instanceof FirebaseError) {\n            logger.warn(e.message);\n        }\n        else {\n            const idbGetError = ERROR_FACTORY.create(\"idb-get\" /* AppError.IDB_GET */, {\n                originalErrorMessage: e === null || e === void 0 ? void 0 : e.message\n            });\n            logger.warn(idbGetError.message);\n        }\n    }\n}\nasync function writeHeartbeatsToIndexedDB(app, heartbeatObject) {\n    try {\n        const db = await getDbPromise();\n        const tx = db.transaction(STORE_NAME, 'readwrite');\n        const objectStore = tx.objectStore(STORE_NAME);\n        await objectStore.put(heartbeatObject, computeKey(app));\n        await tx.done;\n    }\n    catch (e) {\n        if (e instanceof FirebaseError) {\n            logger.warn(e.message);\n        }\n        else {\n            const idbGetError = ERROR_FACTORY.create(\"idb-set\" /* AppError.IDB_WRITE */, {\n                originalErrorMessage: e === null || e === void 0 ? void 0 : e.message\n            });\n            logger.warn(idbGetError.message);\n        }\n    }\n}\nfunction computeKey(app) {\n    return `${app.name}!${app.options.appId}`;\n}\n/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nconst MAX_HEADER_BYTES = 1024;\nconst MAX_NUM_STORED_HEARTBEATS = 30;\nclass HeartbeatServiceImpl {\n    constructor(container) {\n        this.container = container;\n        /**\n         * In-memory cache for heartbeats, used by getHeartbeatsHeader() to generate\n         * the header string.\n         * Stores one record per date. This will be consolidated into the standard\n         * format of one record per user agent string before being sent as a header.\n         * Populated from indexedDB when the controller is instantiated and should\n         * be kept in sync with indexedDB.\n         * Leave public for easier testing.\n         */\n        this._heartbeatsCache = null;\n        const app = this.container.getProvider('app').getImmediate();\n        this._storage = new HeartbeatStorageImpl(app);\n        this._heartbeatsCachePromise = this._storage.read().then(result => {\n            this._heartbeatsCache = result;\n            return result;\n        });\n    }\n    /**\n     * Called to report a heartbeat. The function will generate\n     * a HeartbeatsByUserAgent object, update heartbeatsCache, and persist it\n     * to IndexedDB.\n     * Note that we only store one heartbeat per day. So if a heartbeat for today is\n     * already logged, subsequent calls to this function in the same day will be ignored.\n     */\n    async triggerHeartbeat() {\n        var _a, _b;\n        try {\n            const platformLogger = this.container\n                .getProvider('platform-logger')\n                .getImmediate();\n            // This is the \"Firebase user agent\" string from the platform logger\n            // service, not the browser user agent.\n            const agent = platformLogger.getPlatformInfoString();\n            const date = getUTCDateString();\n            if (((_a = this._heartbeatsCache) === null || _a === void 0 ? void 0 : _a.heartbeats) == null) {\n                this._heartbeatsCache = await this._heartbeatsCachePromise;\n                // If we failed to construct a heartbeats cache, then return immediately.\n                if (((_b = this._heartbeatsCache) === null || _b === void 0 ? void 0 : _b.heartbeats) == null) {\n                    return;\n                }\n            }\n            // Do not store a heartbeat if one is already stored for this day\n            // or if a header has already been sent today.\n            if (this._heartbeatsCache.lastSentHeartbeatDate === date ||\n                this._heartbeatsCache.heartbeats.some(singleDateHeartbeat => singleDateHeartbeat.date === date)) {\n                return;\n            }\n            else {\n                // There is no entry for this date. Create one.\n                this._heartbeatsCache.heartbeats.push({ date, agent });\n                // If the number of stored heartbeats exceeds the maximum number of stored heartbeats, remove the heartbeat with the earliest date.\n                // 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.\n                if (this._heartbeatsCache.heartbeats.length > MAX_NUM_STORED_HEARTBEATS) {\n                    const earliestHeartbeatIdx = getEarliestHeartbeatIdx(this._heartbeatsCache.heartbeats);\n                    this._heartbeatsCache.heartbeats.splice(earliestHeartbeatIdx, 1);\n                }\n            }\n            return this._storage.overwrite(this._heartbeatsCache);\n        }\n        catch (e) {\n            logger.warn(e);\n        }\n    }\n    /**\n     * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly.\n     * It also clears all heartbeats from memory as well as in IndexedDB.\n     *\n     * NOTE: Consuming product SDKs should not send the header if this method\n     * returns an empty string.\n     */\n    async getHeartbeatsHeader() {\n        var _a;\n        try {\n            if (this._heartbeatsCache === null) {\n                await this._heartbeatsCachePromise;\n            }\n            // If it's still null or the array is empty, there is no data to send.\n            if (((_a = this._heartbeatsCache) === null || _a === void 0 ? void 0 : _a.heartbeats) == null ||\n                this._heartbeatsCache.heartbeats.length === 0) {\n                return '';\n            }\n            const date = getUTCDateString();\n            // Extract as many heartbeats from the cache as will fit under the size limit.\n            const { heartbeatsToSend, unsentEntries } = extractHeartbeatsForHeader(this._heartbeatsCache.heartbeats);\n            const headerString = base64urlEncodeWithoutPadding(JSON.stringify({ version: 2, heartbeats: heartbeatsToSend }));\n            // Store last sent date to prevent another being logged/sent for the same day.\n            this._heartbeatsCache.lastSentHeartbeatDate = date;\n            if (unsentEntries.length > 0) {\n                // Store any unsent entries if they exist.\n                this._heartbeatsCache.heartbeats = unsentEntries;\n                // This seems more likely than emptying the array (below) to lead to some odd state\n                // since the cache isn't empty and this will be called again on the next request,\n                // and is probably safest if we await it.\n                await this._storage.overwrite(this._heartbeatsCache);\n            }\n            else {\n                this._heartbeatsCache.heartbeats = [];\n                // Do not wait for this, to reduce latency.\n                void this._storage.overwrite(this._heartbeatsCache);\n            }\n            return headerString;\n        }\n        catch (e) {\n            logger.warn(e);\n            return '';\n        }\n    }\n}\nfunction getUTCDateString() {\n    const today = new Date();\n    // Returns date format 'YYYY-MM-DD'\n    return today.toISOString().substring(0, 10);\n}\nfunction extractHeartbeatsForHeader(heartbeatsCache, maxSize = MAX_HEADER_BYTES) {\n    // Heartbeats grouped by user agent in the standard format to be sent in\n    // the header.\n    const heartbeatsToSend = [];\n    // Single date format heartbeats that are not sent.\n    let unsentEntries = heartbeatsCache.slice();\n    for (const singleDateHeartbeat of heartbeatsCache) {\n        // Look for an existing entry with the same user agent.\n        const heartbeatEntry = heartbeatsToSend.find(hb => hb.agent === singleDateHeartbeat.agent);\n        if (!heartbeatEntry) {\n            // If no entry for this user agent exists, create one.\n            heartbeatsToSend.push({\n                agent: singleDateHeartbeat.agent,\n                dates: [singleDateHeartbeat.date]\n            });\n            if (countBytes(heartbeatsToSend) > maxSize) {\n                // If the header would exceed max size, remove the added heartbeat\n                // entry and stop adding to the header.\n                heartbeatsToSend.pop();\n                break;\n            }\n        }\n        else {\n            heartbeatEntry.dates.push(singleDateHeartbeat.date);\n            // If the header would exceed max size, remove the added date\n            // and stop adding to the header.\n            if (countBytes(heartbeatsToSend) > maxSize) {\n                heartbeatEntry.dates.pop();\n                break;\n            }\n        }\n        // Pop unsent entry from queue. (Skipped if adding the entry exceeded\n        // quota and the loop breaks early.)\n        unsentEntries = unsentEntries.slice(1);\n    }\n    return {\n        heartbeatsToSend,\n        unsentEntries\n    };\n}\nclass HeartbeatStorageImpl {\n    constructor(app) {\n        this.app = app;\n        this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();\n    }\n    async runIndexedDBEnvironmentCheck() {\n        if (!isIndexedDBAvailable()) {\n            return false;\n        }\n        else {\n            return validateIndexedDBOpenable()\n                .then(() => true)\n                .catch(() => false);\n        }\n    }\n    /**\n     * Read all heartbeats.\n     */\n    async read() {\n        const canUseIndexedDB = await this._canUseIndexedDBPromise;\n        if (!canUseIndexedDB) {\n            return { heartbeats: [] };\n        }\n        else {\n            const idbHeartbeatObject = await readHeartbeatsFromIndexedDB(this.app);\n            if (idbHeartbeatObject === null || idbHeartbeatObject === void 0 ? void 0 : idbHeartbeatObject.heartbeats) {\n                return idbHeartbeatObject;\n            }\n            else {\n                return { heartbeats: [] };\n            }\n        }\n    }\n    // overwrite the storage with the provided heartbeats\n    async overwrite(heartbeatsObject) {\n        var _a;\n        const canUseIndexedDB = await this._canUseIndexedDBPromise;\n        if (!canUseIndexedDB) {\n            return;\n        }\n        else {\n            const existingHeartbeatsObject = await this.read();\n            return writeHeartbeatsToIndexedDB(this.app, {\n                lastSentHeartbeatDate: (_a = heartbeatsObject.lastSentHeartbeatDate) !== null && _a !== void 0 ? _a : existingHeartbeatsObject.lastSentHeartbeatDate,\n                heartbeats: heartbeatsObject.heartbeats\n            });\n        }\n    }\n    // add heartbeats\n    async add(heartbeatsObject) {\n        var _a;\n        const canUseIndexedDB = await this._canUseIndexedDBPromise;\n        if (!canUseIndexedDB) {\n            return;\n        }\n        else {\n            const existingHeartbeatsObject = await this.read();\n            return writeHeartbeatsToIndexedDB(this.app, {\n                lastSentHeartbeatDate: (_a = heartbeatsObject.lastSentHeartbeatDate) !== null && _a !== void 0 ? _a : existingHeartbeatsObject.lastSentHeartbeatDate,\n                heartbeats: [\n                    ...existingHeartbeatsObject.heartbeats,\n                    ...heartbeatsObject.heartbeats\n                ]\n            });\n        }\n    }\n}\n/**\n * Calculate bytes of a HeartbeatsByUserAgent array after being wrapped\n * in a platform logging header JSON object, stringified, and converted\n * to base 64.\n */\nfunction countBytes(heartbeatsCache) {\n    // base64 has a restricted set of characters, all of which should be 1 byte.\n    return base64urlEncodeWithoutPadding(\n    // heartbeatsCache wrapper properties\n    JSON.stringify({ version: 2, heartbeats: heartbeatsCache })).length;\n}\n/**\n * Returns the index of the heartbeat with the earliest date.\n * If the heartbeats array is empty, -1 is returned.\n */\nfunction getEarliestHeartbeatIdx(heartbeats) {\n    if (heartbeats.length === 0) {\n        return -1;\n    }\n    let earliestHeartbeatIdx = 0;\n    let earliestHeartbeatDate = heartbeats[0].date;\n    for (let i = 1; i < heartbeats.length; i++) {\n        if (heartbeats[i].date < earliestHeartbeatDate) {\n            earliestHeartbeatDate = heartbeats[i].date;\n            earliestHeartbeatIdx = i;\n        }\n    }\n    return earliestHeartbeatIdx;\n}\n/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nfunction registerCoreComponents(variant) {\n    _registerComponent(new Component('platform-logger', container => new PlatformLoggerServiceImpl(container), \"PRIVATE\" /* ComponentType.PRIVATE */));\n    _registerComponent(new Component('heartbeat', container => new HeartbeatServiceImpl(container), \"PRIVATE\" /* ComponentType.PRIVATE */));\n    // Register `app` package.\n    registerVersion(name$q, version$1, variant);\n    // BUILD_TARGET will be replaced by values like esm2017, cjs2017, etc during the compilation\n    registerVersion(name$q, version$1, 'esm2017');\n    // Register platform SDK identifier (no version).\n    registerVersion('fire-js', '');\n}\n/**\n * Firebase App\n *\n * @remarks This package coordinates the communication between the different Firebase components\n * @packageDocumentation\n */\nregisterCoreComponents('');\n\nvar name = \"firebase\";\nvar version = \"11.5.0\";\n\n/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nregisterVersion(name, version, 'cdn');\n\nexport { FirebaseError, SDK_VERSION, DEFAULT_ENTRY_NAME as _DEFAULT_ENTRY_NAME, _addComponent, _addOrOverwriteComponent, _apps, _clearComponents, _components, _getProvider, _isFirebaseApp, _isFirebaseServerApp, _registerComponent, _removeServiceInstance, _serverApps, deleteApp, getApp, getApps, initializeApp, initializeServerApp, onLog, registerVersion, setLogLevel };\n\n//# sourceMappingURL=firebase-app.js.map\n"],
  "mappings": "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",
  "names": ["getDefaultsFromPostinstall", "stringToByteArray$1", "str", "out", "p", "i", "c", "byteArrayToString", "bytes", "pos", "c1", "c2", "c3", "c4", "u", "base64", "input", "webSafe", "byteToCharMap", "output", "byte1", "haveByte2", "byte2", "haveByte3", "byte3", "outByte1", "outByte2", "outByte3", "outByte4", "charToByteMap", "byte4", "DecodeBase64StringError", "base64Encode", "utf8Bytes", "base64urlEncodeWithoutPadding", "base64Decode", "getGlobal", "window", "global", "getDefaultsFromGlobal", "getDefaultsFromEnvVariable", "defaultsJsonString", "getDefaultsFromCookie", "match", "decoded", "getDefaults", "e", "getDefaultAppConfig", "_a", "Deferred", "resolve", "reject", "callback", "error", "value", "isIndexedDBAvailable", "validateIndexedDBOpenable", "resolve", "reject", "preExist", "DB_CHECK_NAME", "request", "_a", "error", "ERROR_NAME", "FirebaseError", "_FirebaseError", "code", "message", "customData", "ErrorFactory", "service", "serviceName", "errors", "data", "fullCode", "template", "replaceTemplate", "fullMessage", "PATTERN", "_", "key", "value", "deepEqual", "a", "b", "aKeys", "bKeys", "k", "aProp", "bProp", "isObject", "thing", "Component", "name", "instanceFactory", "type", "mode", "multipleInstances", "props", "callback", "DEFAULT_ENTRY_NAME$1", "Provider", "container", "identifier", "normalizedIdentifier", "deferred", "Deferred", "instance", "options", "optional", "e", "component", "isComponentEager", "instanceIdentifier", "instanceDeferred", "services", "opts", "normalizedDeferredIdentifier", "existingCallbacks", "existingInstance", "callbacks", "normalizeIdentifierForFactory", "ComponentContainer", "provider", "instances", "LogLevel", "levelStringToEnum", "defaultLogLevel", "ConsoleMethod", "defaultLogHandler", "logType", "args", "now", "method", "Logger", "val", "instanceOfAny", "object", "constructors", "c", "idbProxyableTypes", "cursorAdvanceMethods", "getIdbProxyableTypes", "getCursorAdvanceMethods", "cursorRequestMap", "transactionDoneMap", "transactionStoreNamesMap", "transformCache", "reverseTransformCache", "promisifyRequest", "request", "promise", "resolve", "reject", "unlisten", "success", "error", "wrap", "value", "cacheDonePromiseForTransaction", "tx", "done", "complete", "idbProxyTraps", "target", "prop", "receiver", "replaceTraps", "callback", "wrapFunction", "func", "storeNames", "args", "unwrap", "transformCachableValue", "newValue", "openDB", "name", "version", "blocked", "upgrade", "blocking", "terminated", "openPromise", "event", "db", "readMethods", "writeMethods", "cachedMethods", "getMethod", "targetFuncName", "useIndex", "isWrite", "method", "storeName", "oldTraps", "PlatformLoggerServiceImpl", "container", "provider", "isVersionServiceProvider", "service", "logString", "component", "name$q", "version$1", "logger", "Logger", "name$p", "name$o", "name$n", "name$m", "name$l", "name$k", "name$j", "name$i", "name$h", "name$g", "name$f", "name$e", "name$d", "name$c", "name$b", "name$a", "name$9", "name$8", "name$7", "name$6", "name$5", "name$4", "name$3", "name$2", "name$1", "name$r", "version$2", "DEFAULT_ENTRY_NAME", "PLATFORM_LOG_STRING", "_apps", "_serverApps", "_components", "_addComponent", "app", "e", "_registerComponent", "component", "componentName", "_components", "logger", "app", "_apps", "_addComponent", "serverApp", "_serverApps", "_getProvider", "name", "heartbeatController", "_isFirebaseServerApp", "obj", "ERRORS", "ERROR_FACTORY", "ErrorFactory", "FirebaseAppImpl", "options", "config", "container", "Component", "val", "SDK_VERSION", "version$2", "initializeApp", "_options", "rawConfig", "options", "config", "DEFAULT_ENTRY_NAME", "name", "ERROR_FACTORY", "getDefaultAppConfig", "existingApp", "_apps", "deepEqual", "container", "ComponentContainer", "component", "_components", "newApp", "FirebaseAppImpl", "getApp", "name", "DEFAULT_ENTRY_NAME", "app", "_apps", "getDefaultAppConfig", "initializeApp", "ERROR_FACTORY", "getApps", "registerVersion", "libraryKeyOrName", "version", "variant", "_a", "library", "PLATFORM_LOG_STRING", "libraryMismatch", "versionMismatch", "warning", "logger", "_registerComponent", "Component", "DB_NAME", "DB_VERSION", "STORE_NAME", "dbPromise", "getDbPromise", "openDB", "db", "oldVersion", "e", "ERROR_FACTORY", "readHeartbeatsFromIndexedDB", "app", "tx", "result", "computeKey", "FirebaseError", "logger", "idbGetError", "writeHeartbeatsToIndexedDB", "heartbeatObject", "MAX_HEADER_BYTES", "MAX_NUM_STORED_HEARTBEATS", "HeartbeatServiceImpl", "container", "HeartbeatStorageImpl", "_a", "_b", "agent", "date", "getUTCDateString", "singleDateHeartbeat", "earliestHeartbeatIdx", "getEarliestHeartbeatIdx", "heartbeatsToSend", "unsentEntries", "extractHeartbeatsForHeader", "headerString", "base64urlEncodeWithoutPadding", "heartbeatsCache", "maxSize", "heartbeatEntry", "hb", "countBytes", "isIndexedDBAvailable", "validateIndexedDBOpenable", "idbHeartbeatObject", "heartbeatsObject", "existingHeartbeatsObject", "heartbeats", "earliestHeartbeatDate", "i", "registerCoreComponents", "variant", "_registerComponent", "Component", "PlatformLoggerServiceImpl", "registerVersion", "name$q", "version$1", "name", "version"]
}