https://daily.cat/firebase-messaging-sw.js

1(function () {
2    'use strict';
3
4    const getDefaultsFromPostinstall = () => (undefined);
5
6    /**
7     * @license
8     * Copyright 2017 Google LLC
9     *
10     * Licensed under the Apache License, Version 2.0 (the "License");
11     * you may not use this file except in compliance with the License.
12     * You may obtain a copy of the License at
13     *
14     *   http://www.apache.org/licenses/LICENSE-2.0
15     *
16     * Unless required by applicable law or agreed to in writing, software
17     * distributed under the License is distributed on an "AS IS" BASIS,
18     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
19     * See the License for the specific language governing permissions and
20     * limitations under the License.
21     */
22    const stringToByteArray$1 = function (str) {
23        // TODO(user): Use native implementations if/when available
24        const out = [];
25        let p = 0;
26        for (let i = 0; i < str.length; i++) {
27            let c = str.charCodeAt(i);
28            if (c < 128) {
29                out[p++] = c;
30            }
31            else if (c < 2048) {
32                out[p++] = (c >> 6) | 192;
33                out[p++] = (c & 63) | 128;
34            }
35            else if ((c & 0xfc00) === 0xd800 &&
36                i + 1 < str.length &&
37                (str.charCodeAt(i + 1) & 0xfc00) === 0xdc00) {
38                // Surrogate Pair
39                c = 0x10000 + ((c & 0x03ff) << 10) + (str.charCodeAt(++i) & 0x03ff);
40                out[p++] = (c >> 18) | 240;
41                out[p++] = ((c >> 12) & 63) | 128;
42                out[p++] = ((c >> 6) & 63) | 128;
43                out[p++] = (c & 63) | 128;
44            }
45            else {
46                out[p++] = (c >> 12) | 224;
47                out[p++] = ((c >> 6) & 63) | 128;
48                out[p++] = (c & 63) | 128;
49            }
50        }
51        return out;
52    };
53    /**
54     * Turns an array of numbers into the string given by the concatenation of the
55     * characters to which the numbers correspond.
56     * @param bytes Array of numbers representing characters.
57     * @return Stringification of the array.
58     */
59    const byteArrayToString = function (bytes) {
60        // TODO(user): Use native implementations if/when available
61        const out = [];
62        let pos = 0, c = 0;
63        while (pos < bytes.length) {
64            const c1 = bytes[pos++];
65            if (c1 < 128) {
66                out[c++] = String.fromCharCode(c1);
67            }
68            else if (c1 > 191 && c1 < 224) {
69                const c2 = bytes[pos++];
70                out[c++] = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));
71            }
72            else if (c1 > 239 && c1 < 365) {
73                // Surrogate Pair
74                const c2 = bytes[pos++];
75                const c3 = bytes[pos++];
76                const c4 = bytes[pos++];
77                const u = (((c1 & 7) << 18) | ((c2 & 63) << 12) | ((c3 & 63) << 6) | (c4 & 63)) -
78                    0x10000;
79                out[c++] = String.fromCharCode(0xd800 + (u >> 10));
80                out[c++] = String.fromCharCode(0xdc00 + (u & 1023));
81            }
82            else {
83                const c2 = bytes[pos++];
84                const c3 = bytes[pos++];
85                out[c++] = String.fromCharCode(((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
86            }
87        }
88        return out.join('');
89    };
90    // We define it as an object literal instead of a class because a class compiled down to es5 can't
91    // be treeshaked. https://github.com/rollup/rollup/issues/1691
92    // Static lookup maps, lazily populated by init_()
93    // TODO(dlarocque): Define this as a class, since we no longer target ES5.
94    const base64 = {
95        /**
96         * Maps bytes to characters.
97         */
98        byteToCharMap_: null,
99        /**
100         * Maps characters to bytes.
101         */
102        charToByteMap_: null,
103        /**
104         * Maps bytes to websafe characters.
105         * @private
106         */
107        byteToCharMapWebSafe_: null,
108        /**
109         * Maps websafe characters to bytes.
110         * @private
111         */
112        charToByteMapWebSafe_: null,
113        /**
114         * Our default alphabet, shared between
115         * ENCODED_VALS and ENCODED_VALS_WEBSAFE
116         */
117        ENCODED_VALS_BASE: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + 'abcdefghijklmnopqrstuvwxyz' + '0123456789',
118        /**
119         * Our default alphabet. Value 64 (=) is special; it means "nothing."
120         */
121        get ENCODED_VALS() {
122            return this.ENCODED_VALS_BASE + '+/=';
123        },
124        /**
125         * Our websafe alphabet.
126         */
127        get ENCODED_VALS_WEBSAFE() {
128            return this.ENCODED_VALS_BASE + '-_.';
129        },
130        /**
131         * Whether this browser supports the atob and btoa functions. This extension
132         * started at Mozilla but is now implemented by many browsers. We use the
133         * ASSUME_* variables to avoid pulling in the full useragent detection library
134         * but still allowing the standard per-browser compilations.
135         *
136         */
137        HAS_NATIVE_SUPPORT: typeof atob === 'function',
138        /**
139         * Base64-encode an array of bytes.
140         *
141         * @param input An array of bytes (numbers with
142         *     value in [0, 255]) to encode.
143         * @param webSafe Boolean indicating we should use the
144         *     alternative alphabet.
145         * @return The base64 encoded string.
146         */
147        encodeByteArray(input, webSafe) {
148            if (!Array.isArray(input)) {
149                throw Error('encodeByteArray takes an array as a parameter');
150            }
151            this.init_();
152            const byteToCharMap = webSafe
153                ? this.byteToCharMapWebSafe_
154                : this.byteToCharMap_;
155            const output = [];
156            for (let i = 0; i < input.length; i += 3) {
157                const byte1 = input[i];
158                const haveByte2 = i + 1 < input.length;
159                const byte2 = haveByte2 ? input[i + 1] : 0;
160                const haveByte3 = i + 2 < input.length;
161                const byte3 = haveByte3 ? input[i + 2] : 0;
162                const outByte1 = byte1 >> 2;
163                const outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);
164                let outByte3 = ((byte2 & 0x0f) << 2) | (byte3 >> 6);
165                let outByte4 = byte3 & 0x3f;
166                if (!haveByte3) {
167                    outByte4 = 64;
168                    if (!haveByte2) {
169                        outByte3 = 64;
170                    }
171                }
172                output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
173            }
174            return output.join('');
175        },
176        /**
177         * Base64-encode a string.
178         *
179         * @param input A string to encode.
180         * @param webSafe If true, we should use the
181         *     alternative alphabet.
182         * @return The base64 encoded string.
183         */
184        encodeString(input, webSafe) {
185            // Shortcut for Mozilla browsers that implement
186            // a native base64 encoder in the form of "btoa/atob"
187            if (this.HAS_NATIVE_SUPPORT && !webSafe) {
188                return btoa(input);
189            }
190            return this.encodeByteArray(stringToByteArray$1(input), webSafe);
191        },
192        /**
193         * Base64-decode a string.
194         *
195         * @param input to decode.
196         * @param webSafe True if we should use the
197         *     alternative alphabet.
198         * @return string representing the decoded value.
199         */
200        decodeString(input, webSafe) {
201            // Shortcut for Mozilla browsers that implement
202            // a native base64 encoder in the form of "btoa/atob"
203            if (this.HAS_NATIVE_SUPPORT && !webSafe) {
204                return atob(input);
205            }
206            return byteArrayToString(this.decodeStringToByteArray(input, webSafe));
207        },
208        /**
209         * Base64-decode a string.
210         *
211         * In base-64 decoding, groups of four characters are converted into three
212         * bytes.  If the encoder did not apply padding, the input length may not
213         * be a multiple of 4.
214         *
215         * In this case, the last group will have fewer than 4 characters, and
216         * padding will be inferred.  If the group has one or two characters, it decodes
217         * to one byte.  If the group has three characters, it decodes to two bytes.
218         *
219         * @param input Input to decode.
220         * @param webSafe True if we should use the web-safe alphabet.
221         * @return bytes representing the decoded value.
222         */
223        decodeStringToByteArray(input, webSafe) {
224            this.init_();
225            const charToByteMap = webSafe
226                ? this.charToByteMapWebSafe_
227                : this.charToByteMap_;
228            const output = [];
229            for (let i = 0; i < input.length;) {
230                const byte1 = charToByteMap[input.charAt(i++)];
231                const haveByte2 = i < input.length;
232                const byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;
233                ++i;
234                const haveByte3 = i < input.length;
235                const byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;
236                ++i;
237                const haveByte4 = i < input.length;
238                const byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;
239                ++i;
240                if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {
241                    throw new DecodeBase64StringError();
242                }
243                const outByte1 = (byte1 << 2) | (byte2 >> 4);
244                output.push(outByte1);
245                if (byte3 !== 64) {
246                    const outByte2 = ((byte2 << 4) & 0xf0) | (byte3 >> 2);
247                    output.push(outByte2);
248                    if (byte4 !== 64) {
249                        const outByte3 = ((byte3 << 6) & 0xc0) | byte4;
250                        output.push(outByte3);
251                    }
252                }
253            }
254            return output;
255        },
256        /**
257         * Lazy static initialization function. Called before
258         * accessing any of the static map variables.
259         * @private
260         */
261        init_() {
262            if (!this.byteToCharMap_) {
263                this.byteToCharMap_ = {};
264                this.charToByteMap_ = {};
265                this.byteToCharMapWebSafe_ = {};
266                this.charToByteMapWebSafe_ = {};
267                // We want quick mappings back and forth, so we precompute two maps.
268                for (let i = 0; i < this.ENCODED_VALS.length; i++) {
269                    this.byteToCharMap_[i] = this.ENCODED_VALS.charAt(i);
270                    this.charToByteMap_[this.byteToCharMap_[i]] = i;
271                    this.byteToCharMapWebSafe_[i] = this.ENCODED_VALS_WEBSAFE.charAt(i);
272                    this.charToByteMapWebSafe_[this.byteToCharMapWebSafe_[i]] = i;
273                    // Be forgiving when decoding and correctly decode both encodings.
274                    if (i >= this.ENCODED_VALS_BASE.length) {
275                        this.charToByteMap_[this.ENCODED_VALS_WEBSAFE.charAt(i)] = i;
276                        this.charToByteMapWebSafe_[this.ENCODED_VALS.charAt(i)] = i;
277                    }
278                }
279            }
280        }
281    };
282    /**
283     * An error encountered while decoding base64 string.
284     */
285    class DecodeBase64StringError extends Error {
286        constructor() {
287            super(...arguments);
288            this.name = 'DecodeBase64StringError';
289        }
290    }
291    /**
292     * URL-safe base64 encoding
293     */
294    const base64Encode = function (str) {
295        const utf8Bytes = stringToByteArray$1(str);
296        return base64.encodeByteArray(utf8Bytes, true);
297    };
298    /**
299     * URL-safe base64 encoding (without "." padding in the end).
300     * e.g. Used in JSON Web Token (JWT) parts.
301     */
302    const base64urlEncodeWithoutPadding = function (str) {
303        // Use base64url encoding and remove padding in the end (dot characters).
304        return base64Encode(str).replace(/\./g, '');
305    };
306    /**
307     * URL-safe base64 decoding
308     *
309     * NOTE: DO NOT use the global atob() function - it does NOT support the
310     * base64Url variant encoding.
311     *
312     * @param str To be decoded
313     * @return Decoded result, if possible
314     */
315    const base64Decode = function (str) {
316        try {
317            return base64.decodeString(str, true);
318        }
319        catch (e) {
320            console.error('base64Decode failed: ', e);
321        }
322        return null;
323    };
324
325    /**
326     * @license
327     * Copyright 2022 Google LLC
328     *
329     * Licensed under the Apache License, Version 2.0 (the "License");
330     * you may not use this file except in compliance with the License.
331     * You may obtain a copy of the License at
332     *
333     *   http://www.apache.org/licenses/LICENSE-2.0
334     *
335     * Unless required by applicable law or agreed to in writing, software
336     * distributed under the License is distributed on an "AS IS" BASIS,
337     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
338     * See the License for the specific language governing permissions and
339     * limitations under the License.
340     */
341    /**
342     * Polyfill for `globalThis` object.
343     * @returns the `globalThis` object for the given environment.
344     * @public
345     */
346    function getGlobal() {
347        if (typeof self !== 'undefined') {
348            return self;
349        }
350        if (typeof window !== 'undefined') {
351            return window;
352        }
353        if (typeof global !== 'undefined') {
354            return global;
355        }
356        throw new Error('Unable to locate global object.');
357    }
358
359    /**
360     * @license
361     * Copyright 2022 Google LLC
362     *
363     * Licensed under the Apache License, Version 2.0 (the "License");
364     * you may not use this file except in compliance with the License.
365     * You may obtain a copy of the License at
366     *
367     *   http://www.apache.org/licenses/LICENSE-2.0
368     *
369     * Unless required by applicable law or agreed to in writing, software
370     * distributed under the License is distributed on an "AS IS" BASIS,
371     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
372     * See the License for the specific language governing permissions and
373     * limitations under the License.
374     */
375    const getDefaultsFromGlobal = () => getGlobal().__FIREBASE_DEFAULTS__;
376    /**
377     * Attempt to read defaults from a JSON string provided to
378     * process(.)env(.)__FIREBASE_DEFAULTS__ or a JSON file whose path is in
379     * process(.)env(.)__FIREBASE_DEFAULTS_PATH__
380     * The dots are in parens because certain compilers (Vite?) cannot
381     * handle seeing that variable in comments.
382     * See https://github.com/firebase/firebase-js-sdk/issues/6838
383     */
384    const getDefaultsFromEnvVariable = () => {
385        if (typeof process === 'undefined' || typeof process.env === 'undefined') {
386            return;
387        }
388        const defaultsJsonString = process.env.__FIREBASE_DEFAULTS__;
389        if (defaultsJsonString) {
390            return JSON.parse(defaultsJsonString);
391        }
392    };
393    const getDefaultsFromCookie = () => {
394        if (typeof document === 'undefined') {
395            return;
396        }
397        let match;
398        try {
399            match = document.cookie.match(/__FIREBASE_DEFAULTS__=([^;]+)/);
400        }
401        catch (e) {
402            // Some environments such as Angular Universal SSR have a
403            // `document` object but error on accessing `document.cookie`.
404            return;
405        }
406        const decoded = match && base64Decode(match[1]);
407        return decoded && JSON.parse(decoded);
408    };
409    /**
410     * Get the __FIREBASE_DEFAULTS__ object. It checks in order:
411     * (1) if such an object exists as a property of `globalThis`
412     * (2) if such an object was provided on a shell environment variable
413     * (3) if such an object exists in a cookie
414     * @public
415     */
416    const getDefaults = () => {
417        try {
418            return (getDefaultsFromPostinstall() ||
419                getDefaultsFromGlobal() ||
420                getDefaultsFromEnvVariable() ||
421                getDefaultsFromCookie());
422        }
423        catch (e) {
424            /**
425             * Catch-all for being unable to get __FIREBASE_DEFAULTS__ due
426             * to any environment case we have not accounted for. Log to
427             * info instead of swallowing so we can find these unknown cases
428             * and add paths for them if needed.
429             */
430            console.info(`Unable to get __FIREBASE_DEFAULTS__ due to: ${e}`);
431            return;
432        }
433    };
434    /**
435     * Returns Firebase app config stored in the __FIREBASE_DEFAULTS__ object.
436     * @public
437     */
438    const getDefaultAppConfig = () => getDefaults()?.config;
439
440    /**
441     * @license
442     * Copyright 2017 Google LLC
443     *
444     * Licensed under the Apache License, Version 2.0 (the "License");

658            }
659            const aProp = a[k];
660            const bProp = b[k];
661            if (isObject(aProp) && isObject(bProp)) {
662                if (!deepEqual(aProp, bProp)) {
663                    return false;
664                }
665            }
666            else if (aProp !== bProp) {
667                return false;
668            }
669        }
670        for (const k of bKeys) {
671            if (!aKeys.includes(k)) {
672                return false;
673            }
674        }
675        return true;
676    }
677    function isObject(thing) {
678        return thing !== null && typeof thing === 'object';
679    }
680
681    /**
682     * @license
683     * Copyright 2021 Google LLC
684     *
685     * Licensed under the Apache License, Version 2.0 (the "License");
686     * you may not use this file except in compliance with the License.
687     * You may obtain a copy of the License at
688     *
689     *   http://www.apache.org/licenses/LICENSE-2.0
690     *
691     * Unless required by applicable law or agreed to in writing, software
692     * distributed under the License is distributed on an "AS IS" BASIS,
693     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
694     * See the License for the specific language governing permissions and
695     * limitations under the License.
696     */
697    function getModularInstance(service) {
698        if (service && service._delegate) {
699            return service._delegate;
700        }
701        else {
702            return service;
703        }
704    }
705
706    /**
707     * Component for service name T, e.g. `auth`, `auth-internal`
708     */
709    class Component {
710        /**
711         *
712         * @param name The public service name, e.g. app, auth, firestore, database
713         * @param instanceFactory Service factory responsible for creating the public interface
714         * @param type whether the service provided by the component is public or private
715         */
716        constructor(name, instanceFactory, type) {
717            this.name = name;
718            this.instanceFactory = instanceFactory;
719            this.type = type;
720            this.multipleInstances = false;
721            /**
722             * Properties to be added to the service namespace
723             */
724            this.serviceProps = {};
725            this.instantiationMode = "LAZY" /* InstantiationMode.LAZY */;
726            this.onInstanceCreated = null;
727        }
728        setInstantiationMode(mode) {
729            this.instantiationMode = mode;
730            return this;
731        }
732        setMultipleInstances(multipleInstances) {
733            this.multipleInstances = multipleInstances;
734            return this;
735        }
736        setServiceProps(props) {
737            this.serviceProps = props;
738            return this;
739        }
740        setInstanceCreatedCallback(callback) {
741            this.onInstanceCreated = callback;
742            return this;
743        }
744    }
745
746    /**
747     * @license
748     * Copyright 2019 Google LLC
749     *
750     * Licensed under the Apache License, Version 2.0 (the "License");
751     * you may not use this file except in compliance with the License.
752     * You may obtain a copy of the License at
753     *
754     *   http://www.apache.org/licenses/LICENSE-2.0
755     *
756     * Unless required by applicable law or agreed to in writing, software
757     * distributed under the License is distributed on an "AS IS" BASIS,
758     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
759     * See the License for the specific language governing permissions and
760     * limitations under the License.
761     */
762    const DEFAULT_ENTRY_NAME$1 = '[DEFAULT]';
763
764    /**
765     * @license
766     * Copyright 2019 Google LLC
767     *
768     * Licensed under the Apache License, Version 2.0 (the "License");
769     * you may not use this file except in compliance with the License.
770     * You may obtain a copy of the License at
771     *
772     *   http://www.apache.org/licenses/LICENSE-2.0
773     *
774     * Unless required by applicable law or agreed to in writing, software
775     * distributed under the License is distributed on an "AS IS" BASIS,
776     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
777     * See the License for the specific language governing permissions and
778     * limitations under the License.
779     */
780    /**
781     * Provider for instance for service name T, e.g. 'auth', 'auth-internal'
782     * NameServiceMapping[T] is an alias for the type of the instance
783     */
784    class Provider {
785        constructor(name, container) {
786            this.name = name;
787            this.container = container;
788            this.component = null;
789            this.instances = new Map();
790            this.instancesDeferred = new Map();
791            this.instancesOptions = new Map();
792            this.onInitCallbacks = new Map();
793        }
794        /**
795         * @param identifier A provider can provide multiple instances of a service
796         * if this.component.multipleInstances is true.
797         */
798        get(identifier) {
799            // if multipleInstances is not supported, use the default name
800            const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);
801            if (!this.instancesDeferred.has(normalizedIdentifier)) {
802                const deferred = new Deferred();
803                this.instancesDeferred.set(normalizedIdentifier, deferred);
804                if (this.isInitialized(normalizedIdentifier) ||
805                    this.shouldAutoInitialize()) {
806                    // initialize the service if it can be auto-initialized
807                    try {
808                        const instance = this.getOrInitializeService({
809                            instanceIdentifier: normalizedIdentifier
810                        });
811                        if (instance) {
812                            deferred.resolve(instance);
813                        }
814                    }
815                    catch (e) {
816                        // when the instance factory throws an exception during get(), it should not cause
817                        // a fatal error. We just return the unresolved promise in this case.
818                    }
819                }
820            }
821            return this.instancesDeferred.get(normalizedIdentifier).promise;
822        }
823        getImmediate(options) {
824            // if multipleInstances is not supported, use the default name
825            const normalizedIdentifier = this.normalizeInstanceIdentifier(options?.identifier);
826            const optional = options?.optional ?? false;
827            if (this.isInitialized(normalizedIdentifier) ||
828                this.shouldAutoInitialize()) {
829                try {
830                    return this.getOrInitializeService({
831                        instanceIdentifier: normalizedIdentifier
832                    });
833                }
834                catch (e) {
835                    if (optional) {
836                        return null;
837                    }
838                    else {
839                        throw e;
840                    }
841                }
842            }
843            else {
844                // 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
845                if (optional) {
846                    return null;
847                }
848                else {
849                    throw Error(`Service ${this.name} is not available`);
850                }
851            }
852        }
853        getComponent() {
854            return this.component;
855        }
856        setComponent(component) {
857            if (component.name !== this.name) {
858                throw Error(`Mismatching Component ${component.name} for Provider ${this.name}.`);
859            }
860            if (this.component) {
861                throw Error(`Component for ${this.name} has already been provided`);
862            }
863            this.component = component;
864            // return early without attempting to initialize the component if the component requires explicit initialization (calling `Provider.initialize()`)
865            if (!this.shouldAutoInitialize()) {
866                return;
867            }
868            // if the service is eager, initialize the default instance
869            if (isComponentEager(component)) {
870                try {
871                    this.getOrInitializeService({ instanceIdentifier: DEFAULT_ENTRY_NAME$1 });
872                }
873                catch (e) {
874                    // when the instance factory for an eager Component throws an exception during the eager
875                    // initialization, it should not cause a fatal error.
876                    // TODO: Investigate if we need to make it configurable, because some component may want to cause
877                    // a fatal error in this case?
878                }
879            }
880            // Create service instances for the pending promises and resolve them
881            // NOTE: if this.multipleInstances is false, only the default instance will be created
882            // and all promises with resolve with it regardless of the identifier.
883            for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) {
884                const normalizedIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier);
885                try {
886                    // `getOrInitializeService()` should always return a valid instance since a component is guaranteed. use ! to make typescript happy.
887                    const instance = this.getOrInitializeService({
888                        instanceIdentifier: normalizedIdentifier
889                    });
890                    instanceDeferred.resolve(instance);
891                }
892                catch (e) {
893                    // when the instance factory throws an exception, it should not cause
894                    // a fatal error. We just leave the promise unresolved.
895                }
896            }
897        }
898        clearInstance(identifier = DEFAULT_ENTRY_NAME$1) {
899            this.instancesDeferred.delete(identifier);
900            this.instancesOptions.delete(identifier);
901            this.instances.delete(identifier);
902        }
903        // app.delete() will call this method on every provider to delete the services
904        // TODO: should we mark the provider as deleted?
905        async delete() {
906            const services = Array.from(this.instances.values());
907            await Promise.all([
908                ...services
909                    .filter(service => 'INTERNAL' in service) // legacy services
910                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
911                    .map(service => service.INTERNAL.delete()),
912                ...services
913                    .filter(service => '_delete' in service) // modularized services
914                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
915                    .map(service => service._delete())
916            ]);
917        }
918        isComponentSet() {
919            return this.component != null;
920        }
921        isInitialized(identifier = DEFAULT_ENTRY_NAME$1) {
922            return this.instances.has(identifier);
923        }
924        getOptions(identifier = DEFAULT_ENTRY_NAME$1) {
925            return this.instancesOptions.get(identifier) || {};
926        }
927        initialize(opts = {}) {
928            const { options = {} } = opts;
929            const normalizedIdentifier = this.normalizeInstanceIdentifier(opts.instanceIdentifier);
930            if (this.isInitialized(normalizedIdentifier)) {
931                throw Error(`${this.name}(${normalizedIdentifier}) has already been initialized`);
932            }
933            if (!this.isComponentSet()) {
934                throw Error(`Component ${this.name} has not been registered yet`);
935            }
936            const instance = this.getOrInitializeService({
937                instanceIdentifier: normalizedIdentifier,
938                options
939            });
940            // resolve any pending promise waiting for the service instance
941            for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) {
942                const normalizedDeferredIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier);
943                if (normalizedIdentifier === normalizedDeferredIdentifier) {
944                    instanceDeferred.resolve(instance);
945                }
946            }
947            return instance;
948        }
949        /**
950         *
951         * @param callback - a function that will be invoked  after the provider has been initialized by calling provider.initialize().
952         * The function is invoked SYNCHRONOUSLY, so it should not execute any longrunning tasks in order to not block the program.
953         *
954         * @param identifier An optional instance identifier
955         * @returns a function to unregister the callback
956         */
957        onInit(callback, identifier) {
958            const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);
959            const existingCallbacks = this.onInitCallbacks.get(normalizedIdentifier) ??
960                new Set();
961            existingCallbacks.add(callback);
962            this.onInitCallbacks.set(normalizedIdentifier, existingCallbacks);
963            const existingInstance = this.instances.get(normalizedIdentifier);
964            if (existingInstance) {
965                callback(existingInstance, normalizedIdentifier);
966            }
967            return () => {
968                existingCallbacks.delete(callback);
969            };
970        }
971        /**
972         * Invoke onInit callbacks synchronously
973         * @param instance the service instance`
974         */
975        invokeOnInitCallbacks(instance, identifier) {
976            const callbacks = this.onInitCallbacks.get(identifier);
977            if (!callbacks) {
978                return;
979            }
980            for (const callback of callbacks) {
981                try {
982                    callback(instance, identifier);
983                }
984                catch {
985                    // ignore errors in the onInit callback
986                }
987            }
988        }
989        getOrInitializeService({ instanceIdentifier, options = {} }) {
990            let instance = this.instances.get(instanceIdentifier);
991            if (!instance && this.component) {
992                instance = this.component.instanceFactory(this.container, {
993                    instanceIdentifier: normalizeIdentifierForFactory(instanceIdentifier),
994                    options
995                });
996                this.instances.set(instanceIdentifier, instance);
997                this.instancesOptions.set(instanceIdentifier, options);
998                /**
999                 * Invoke onInit listeners.
1000                 * Note this.component.onInstanceCreated is different, which is used by the component creator,
1001                 * while onInit listeners are registered by consumers of the provider.
1002                 */
1003                this.invokeOnInitCallbacks(instance, instanceIdentifier);
1004                /**
1005                 * Order is important
1006                 * onInstanceCreated() should be called after this.instances.set(instanceIdentifier, instance); which
1007                 * makes `isInitialized()` return true.
1008                 */
1009                if (this.component.onInstanceCreated) {
1010                    try {
1011                        this.component.onInstanceCreated(this.container, instanceIdentifier, instance);
1012                    }
1013                    catch {
1014                        // ignore errors in the onInstanceCreatedCallback
1015                    }
1016                }
1017            }
1018            return instance || null;
1019        }
1020        normalizeInstanceIdentifier(identifier = DEFAULT_ENTRY_NAME$1) {
1021            if (this.component) {
1022                return this.component.multipleInstances ? identifier : DEFAULT_ENTRY_NAME$1;
1023            }
1024            else {
1025                return identifier; // assume multiple instances are supported before the component is provided.
1026            }
1027        }
1028        shouldAutoInitialize() {
1029            return (!!this.component &&
1030                this.component.instantiationMode !== "EXPLICIT" /* InstantiationMode.EXPLICIT */);
1031        }
1032    }
1033    // undefined should be passed to the service factory for the default instance
1034    function normalizeIdentifierForFactory(identifier) {
1035        return identifier === DEFAULT_ENTRY_NAME$1 ? undefined : identifier;
1036    }
1037    function isComponentEager(component) {
1038        return component.instantiationMode === "EAGER" /* InstantiationMode.EAGER */;
1039    }
1040
1041    /**
1042     * @license
1043     * Copyright 2019 Google LLC
1044     *
1045     * Licensed under the Apache License, Version 2.0 (the "License");

1146        LogLevel[LogLevel["ERROR"] = 4] = "ERROR";
1147        LogLevel[LogLevel["SILENT"] = 5] = "SILENT";
1148    })(LogLevel || (LogLevel = {}));
1149    const levelStringToEnum = {
1150        'debug': LogLevel.DEBUG,
1151        'verbose': LogLevel.VERBOSE,
1152        'info': LogLevel.INFO,
1153        'warn': LogLevel.WARN,
1154        'error': LogLevel.ERROR,
1155        'silent': LogLevel.SILENT
1156    };
1157    /**
1158     * The default log level
1159     */
1160    const defaultLogLevel = LogLevel.INFO;
1161    /**
1162     * By default, `console.debug` is not displayed in the developer console (in
1163     * chrome). To avoid forcing users to have to opt-in to these logs twice
1164     * (i.e. once for firebase, and once in the console), we are sending `DEBUG`
1165     * logs to the `console.log` function.
1166     */
1167    const ConsoleMethod = {
1168        [LogLevel.DEBUG]: 'log',
1169        [LogLevel.VERBOSE]: 'log',
1170        [LogLevel.INFO]: 'info',
1171        [LogLevel.WARN]: 'warn',
1172        [LogLevel.ERROR]: 'error'
1173    };
1174    /**
1175     * The default log handler will forward DEBUG, VERBOSE, INFO, WARN, and ERROR
1176     * messages on to their corresponding console counterparts (if the log method
1177     * is supported by the current log level)
1178     */
1179    const defaultLogHandler = (instance, logType, ...args) => {
1180        if (logType < instance.logLevel) {
1181            return;
1182        }
1183        const now = new Date().toISOString();
1184        const method = ConsoleMethod[logType];
1185        if (method) {
1186            console[method](`[${now}]  ${instance.name}:`, ...args);
1187        }
1188        else {
1189            throw new Error(`Attempted to log a message with an invalid logType (value: ${logType})`);
1190        }
1191    };
1192    class Logger {
1193        /**
1194         * Gives you an instance of a Logger to capture messages according to
1195         * Firebase's logging scheme.
1196         *
1197         * @param name The name that the logs will be associated with
1198         */
1199        constructor(name) {
1200            this.name = name;
1201            /**
1202             * The log level of the given Logger instance.
1203             */
1204            this._logLevel = defaultLogLevel;
1205            /**
1206             * The main (internal) log handler for the Logger instance.
1207             * Can be set to a new function in internal package code but not by user.
1208             */
1209            this._logHandler = defaultLogHandler;
1210            /**
1211             * The optional, additional, user-defined log handler for the Logger instance.
1212             */
1213            this._userLogHandler = null;
1214        }
1215        get logLevel() {
1216            return this._logLevel;
1217        }
1218        set logLevel(val) {
1219            if (!(val in LogLevel)) {
1220                throw new TypeError(`Invalid value "${val}" assigned to \`logLevel\``);
1221            }
1222            this._logLevel = val;
1223        }
1224        // Workaround for setter/getter having to be the same type.
1225        setLogLevel(val) {
1226            this._logLevel = typeof val === 'string' ? levelStringToEnum[val] : val;
1227        }
1228        get logHandler() {
1229            return this._logHandler;
1230        }
1231        set logHandler(val) {
1232            if (typeof val !== 'function') {
1233                throw new TypeError('Value assigned to `logHandler` must be a function');
1234            }
1235            this._logHandler = val;
1236        }
1237        get userLogHandler() {
1238            return this._userLogHandler;
1239        }
1240        set userLogHandler(val) {
1241            this._userLogHandler = val;
1242        }
1243        /**
1244         * The functions below are all based on the `console` interface
1245         */
1246        debug(...args) {
1247            this._userLogHandler && this._userLogHandler(this, LogLevel.DEBUG, ...args);
1248            this._logHandler(this, LogLevel.DEBUG, ...args);
1249        }
1250        log(...args) {
1251            this._userLogHandler &&
1252                this._userLogHandler(this, LogLevel.VERBOSE, ...args);
1253            this._logHandler(this, LogLevel.VERBOSE, ...args);
1254        }
1255        info(...args) {
1256            this._userLogHandler && this._userLogHandler(this, LogLevel.INFO, ...args);
1257            this._logHandler(this, LogLevel.INFO, ...args);
1258        }
1259        warn(...args) {
1260            this._userLogHandler && this._userLogHandler(this, LogLevel.WARN, ...args);
1261            this._logHandler(this, LogLevel.WARN, ...args);
1262        }
1263        error(...args) {
1264            this._userLogHandler && this._userLogHandler(this, LogLevel.ERROR, ...args);
1265            this._logHandler(this, LogLevel.ERROR, ...args);
1266        }
1267    }
1268
1269    const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
1270
1271    let idbProxyableTypes;
1272    let cursorAdvanceMethods;
1273    // This is a function to prevent it throwing up in node environments.
1274    function getIdbProxyableTypes() {
1275        return (idbProxyableTypes ||
1276            (idbProxyableTypes = [
1277                IDBDatabase,
1278                IDBObjectStore,
1279                IDBIndex,
1280                IDBCursor,
1281                IDBTransaction,
1282            ]));
1283    }
1284    // This is a function to prevent it throwing up in node environments.
1285    function getCursorAdvanceMethods() {
1286        return (cursorAdvanceMethods ||
1287            (cursorAdvanceMethods = [
1288                IDBCursor.prototype.advance,
1289                IDBCursor.prototype.continue,
1290                IDBCursor.prototype.continuePrimaryKey,
1291            ]));
1292    }
1293    const cursorRequestMap = new WeakMap();
1294    const transactionDoneMap = new WeakMap();
1295    const transactionStoreNamesMap = new WeakMap();
1296    const transformCache = new WeakMap();
1297    const reverseTransformCache = new WeakMap();
1298    function promisifyRequest(request) {
1299        const promise = new Promise((resolve, reject) => {
1300            const unlisten = () => {
1301                request.removeEventListener('success', success);
1302                request.removeEventListener('error', error);
1303            };
1304            const success = () => {
1305                resolve(wrap(request.result));
1306                unlisten();
1307            };
1308            const error = () => {
1309                reject(request.error);
1310                unlisten();
1311            };
1312            request.addEventListener('success', success);
1313            request.addEventListener('error', error);
1314        });
1315        promise
1316            .then((value) => {
1317            // Since cursoring reuses the IDBRequest (*sigh*), we cache it for later retrieval
1318            // (see wrapFunction).
1319            if (value instanceof IDBCursor) {
1320                cursorRequestMap.set(value, request);
1321            }
1322            // Catching to avoid "Uncaught Promise exceptions"
1323        })
1324            .catch(() => { });
1325        // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This
1326        // is because we create many promises from a single IDBRequest.
1327        reverseTransformCache.set(promise, request);
1328        return promise;
1329    }
1330    function cacheDonePromiseForTransaction(tx) {
1331        // Early bail if we've already created a done promise for this transaction.
1332        if (transactionDoneMap.has(tx))
1333            return;
1334        const done = new Promise((resolve, reject) => {
1335            const unlisten = () => {
1336                tx.removeEventListener('complete', complete);
1337                tx.removeEventListener('error', error);
1338                tx.removeEventListener('abort', error);
1339            };
1340            const complete = () => {
1341                resolve();
1342                unlisten();
1343            };
1344            const error = () => {
1345                reject(tx.error || new DOMException('AbortError', 'AbortError'));
1346                unlisten();
1347            };
1348            tx.addEventListener('complete', complete);
1349            tx.addEventListener('error', error);
1350            tx.addEventListener('abort', error);
1351        });
1352        // Cache it for later retrieval.
1353        transactionDoneMap.set(tx, done);
1354    }
1355    let idbProxyTraps = {
1356        get(target, prop, receiver) {
1357            if (target instanceof IDBTransaction) {
1358                // Special handling for transaction.done.
1359                if (prop === 'done')
1360                    return transactionDoneMap.get(target);
1361                // Polyfill for objectStoreNames because of Edge.
1362                if (prop === 'objectStoreNames') {
1363                    return target.objectStoreNames || transactionStoreNamesMap.get(target);
1364                }
1365                // Make tx.store return the only store in the transaction, or undefined if there are many.
1366                if (prop === 'store') {
1367                    return receiver.objectStoreNames[1]
1368                        ? undefined
1369                        : receiver.objectStore(receiver.objectStoreNames[0]);
1370                }
1371            }
1372            // Else transform whatever we get back.
1373            return wrap(target[prop]);
1374        },
1375        set(target, prop, value) {
1376            target[prop] = value;
1377            return true;
1378        },
1379        has(target, prop) {
1380            if (target instanceof IDBTransaction &&
1381                (prop === 'done' || prop === 'store')) {
1382                return true;
1383            }
1384            return prop in target;
1385        },
1386    };
1387    function replaceTraps(callback) {
1388        idbProxyTraps = callback(idbProxyTraps);
1389    }
1390    function wrapFunction(func) {
1391        // Due to expected object equality (which is enforced by the caching in `wrap`), we
1392        // only create one new func per func.
1393        // Edge doesn't support objectStoreNames (booo), so we polyfill it here.
1394        if (func === IDBDatabase.prototype.transaction &&
1395            !('objectStoreNames' in IDBTransaction.prototype)) {
1396            return function (storeNames, ...args) {
1397                const tx = func.call(unwrap(this), storeNames, ...args);
1398                transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);
1399                return wrap(tx);
1400            };
1401        }
1402        // Cursor methods are special, as the behaviour is a little more different to standard IDB. In
1403        // IDB, you advance the cursor and wait for a new 'success' on the ID

1403BRequest that gave you the
1404        // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense
1405        // with real promises, so each advance methods returns a new promise for the cursor object, or
1406        // undefined if the end of the cursor has been reached.
1407        if (getCursorAdvanceMethods().includes(func)) {
1408            return function (...args) {
1409                // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
1410                // the original object.
1411                func.apply(unwrap(this), args);
1412                return wrap(cursorRequestMap.get(this));
1413            };
1414        }
1415        return function (...args) {
1416            // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
1417            // the original object.
1418            return wrap(func.apply(unwrap(this), args));
1419        };
1420    }
1421    function transformCachableValue(value) {
1422        if (typeof value === 'function')
1423            return wrapFunction(value);
1424        // This doesn't return, it just creates a 'done' promise for the transaction,
1425        // which is later returned for transaction.done (see idbObjectHandler).
1426        if (value instanceof IDBTransaction)
1427            cacheDonePromiseForTransaction(value);
1428        if (instanceOfAny(value, getIdbProxyableTypes()))
1429            return new Proxy(value, idbProxyTraps);
1430        // Return the same value back if we're not going to transform it.
1431        return value;
1432    }
1433    function wrap(value) {
1434        // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
1435        // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
1436        if (value instanceof IDBRequest)
1437            return promisifyRequest(value);
1438        // If we've already transformed this value before, reuse the transformed value.
1439        // This is faster, but it also provides object equality.
1440        if (transformCache.has(value))
1441            return transformCache.get(value);
1442        const newValue = transformCachableValue(value);
1443        // Not all types are transformed.
1444        // These may be primitive types, so they can't be WeakMap keys.
1445        if (newValue !== value) {
1446            transformCache.set(value, newValue);
1447            reverseTransformCache.set(newValue, value);
1448        }
1449        return newValue;
1450    }
1451    const unwrap = (value) => reverseTransformCache.get(value);
1452
1453    /**
1454     * Open a database.
1455     *
1456     * @param name Name of the database.
1457     * @param version Schema version.
1458     * @param callbacks Additional callbacks.
1459     */
1460    function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
1461        const request = indexedDB.open(name, version);
1462        const openPromise = wrap(request);
1463        if (upgrade) {
1464            request.addEventListener('upgradeneeded', (event) => {
1465                upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
1466            });
1467        }
1468        if (blocked) {
1469            request.addEventListener('blocked', (event) => blocked(
1470            // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
1471            event.oldVersion, event.newVersion, event));
1472        }
1473        openPromise
1474            .then((db) => {
1475            if (terminated)
1476                db.addEventListener('close', () => terminated());
1477            if (blocking) {
1478                db.addEventListener('versionchange', (event) => blocking(event.oldVersion, event.newVersion, event));
1479            }
1480        })
1481            .catch(() => { });
1482        return openPromise;
1483    }
1484    /**
1485     * Delete a database.
1486     *
1487     * @param name Name of the database.
1488     */
1489    function deleteDB(name, { blocked } = {}) {
1490        const request = indexedDB.deleteDatabase(name);
1491        if (blocked) {
1492            request.addEventListener('blocked', (event) => blocked(
1493            // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
1494            event.oldVersion, event));
1495        }
1496        return wrap(request).then(() => undefined);
1497    }
1498
1499    const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
1500    const writeMethods = ['put', 'add', 'delete', 'clear'];
1501    const cachedMethods = new Map();
1502    function getMethod(target, prop) {
1503        if (!(target instanceof IDBDatabase &&
1504            !(prop in target) &&
1505            typeof prop === 'string')) {
1506            return;
1507        }
1508        if (cachedMethods.get(prop))
1509            return cachedMethods.get(prop);
1510        const targetFuncName = prop.replace(/FromIndex$/, '');
1511        const useIndex = prop !== targetFuncName;
1512        const isWrite = writeMethods.includes(targetFuncName);
1513        if (
1514        // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
1515        !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) ||
1516            !(isWrite || readMethods.includes(targetFuncName))) {
1517            return;
1518        }
1519        const method = async function (storeName, ...args) {
1520            // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(
1521            const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');
1522            let target = tx.store;
1523            if (useIndex)
1524                target = target.index(args.shift());
1525            // Must reject if op rejects.
1526            // If it's a write operation, must reject if tx.done rejects.
1527            // Must reject with op rejection first.
1528            // Must resolve with op value.
1529            // Must handle both promises (no unhandled rejections)
1530            return (await Promise.all([
1531                target[targetFuncName](...args),
1532                isWrite && tx.done,
1533            ]))[0];
1534        };
1535        cachedMethods.set(prop, method);
1536        return method;
1537    }
1538    replaceTraps((oldTraps) => ({
1539        ...oldTraps,
1540        get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
1541        has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop),
1542    }));
1543
1544    /**
1545     * @license
1546     * Copyright 2019 Google LLC
1547     *
1548     * Licensed under the Apache License, Version 2.0 (the "License");

2036are
2037     * distributed under the License is distributed on an "AS IS" BASIS,
2038     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2039     * See the License for the specific language governing permissions and
2040     * limitations under the License.
2041     */
2042    const DB_NAME = 'firebase-heartbeat-database';
2043    const DB_VERSION = 1;
2044    const STORE_NAME = 'firebase-heartbeat-store';
2045    let dbPromise$2 = null;
2046    function getDbPromise$2() {
2047        if (!dbPromise$2) {
2048            dbPromise$2 = openDB(DB_NAME, DB_VERSION, {
2049                upgrade: (db, oldVersion) => {
2050                    // We don't use 'break' in this switch statement, the fall-through
2051                    // behavior is what we want, because if there are multiple versions between
2052                    // the old version and the current version, we want ALL the migrations
2053                    // that correspond to those versions to run, not only the last one.
2054                    // eslint-disable-next-line default-case
2055                    switch (oldVersion) {
2056                        case 0:
2057                            try {
2058                                db.createObjectStore(STORE_NAME);
2059                            }
2060                            catch (e) {
2061                                // Safari/iOS browsers throw occasional exceptions on
2062                                // db.createObjectStore() that may be a bug. Avoid blocking
2063                                // the rest of the app functionality.
2064                                console.warn(e);
2065                            }
2066                    }
2067                }
2068            }).catch(e => {
2069                throw ERROR_FACTORY$2.create("idb-open" /* AppError.IDB_OPEN */, {
2070                    originalErrorMessage: e.message
2071                });
2072            });
2073        }
2074        return dbPromise$2;
2075    }
2076    async function readHeartbeatsFromIndexedDB(app) {
2077        try {
2078            const db = await getDbPromise$2();
2079            const tx = db.transaction(STORE_NAME);
2080            const result = await tx.objectStore(STORE_NAME).get(computeKey(app));
2081            // We already have the value but tx.done can throw,
2082            // so we need to await it here to catch errors
2083            await tx.done;
2084            return result;
2085        }
2086        catch (e) {
2087            if (e instanceof FirebaseError) {
2088                logger.warn(e.message);
2089            }
2090            else {
2091                const idbGetError = ERROR_FACTORY$2.create("idb-get" /* AppError.IDB_GET */, {
2092                    originalErrorMessage: e?.message
2093                });
2094                logger.warn(idbGetError.message);
2095            }
2096        }
2097    }
2098    async function writeHeartbeatsToIndexedDB(app, heartbeatObject) {
2099        try {
2100            const db = await getDbPromise$2();
2101            const tx = db.transaction(STORE_NAME, 'readwrite');
2102            const objectStore = tx.objectStore(STORE_NAME);
2103            await objectStore.put(heartbeatObject, computeKey(app));
2104            await tx.done;
2105        }
2106        catch (e) {
2107            if (e instanceof FirebaseError) {
2108                logger.warn(e.message);
2109            }
2110            else {
2111                const idbGetError = ERROR_FACTORY$2.create("idb-set" /* AppError.IDB_WRITE */, {
2112                    originalErrorMessage: e?.message
2113                });
2114                logger.warn(idbGetError.message);
2115            }
2116        }
2117    }
2118    function computeKey(app) {
2119        return `${app.name}!${app.options.appId}`;
2120    }
2121
2122    /**
2123     * @license
2124     * Copyright 2021 Google LLC
2125     *
2126     * Licensed under the Apache License, Version 2.0 (the "License");
2127     * you may not use this file except in compliance with the License.
2128     * You may obtain a copy of the License at
2129     *
2130     *   http://www.apache.org/licenses/LICENSE-2.0
2131     *
2132     * Unless required by applicable law or agreed to in writing, software
2133     * distributed under the License is distributed on an "AS IS" BASIS,
2134     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2135     * See the License for the specific language governing permissions and
2136     * limitations under the License.
2137     */
2138    const MAX_HEADER_BYTES = 1024;
2139    const MAX_NUM_STORED_HEARTBEATS = 30;
2140    class HeartbeatServiceImpl {
2141        constructor(container) {
2142            this.container = container;
2143            /**
2144             * In-memory cache for heartbeats, used by getHeartbeatsHeader() to generate
2145             * the header string.
2146             * Stores one record per date. This will be consolidated into the standard
2147             * format of one record per user agent string before being sent as a header.
2148             * Populated from indexedDB when the controller is instantiated and should
2149             * be kept in sync with indexedDB.
2150             * Leave public for easier testing.
2151             */
2152            this._heartbeatsCache = null;
2153            const app = this.container.getProvider('app').getImmediate();
2154            this._storage = new HeartbeatStorageImpl(app);
2155            this._heartbeatsCachePromise = this._storage.read().then(result => {
2156                this._heartbeatsCache = result;
2157                return result;
2158            });
2159        }
2160        /**
2161         * Called to report a heartbeat. The function will generate
2162         * a HeartbeatsByUserAgent object, update heartbeatsCache, and persist it
2163         * to IndexedDB.
2164         * Note that we only store one heartbeat per day. So if a heartbeat for today is
2165         * already logged, subsequent calls to this function in the same day will be ignored.
2166         */
2167        async triggerHeartbeat() {
2168            try {
2169                const platformLogger = this.container
2170                    .getProvider('platform-logger')
2171                    .getImmediate();
2172                // This is the "Firebase user agent" string from the platform logger
2173                // service, not the browser user agent.
2174                const agent = platformLogger.getPlatformInfoString();
2175                const date = getUTCDateString();
2176                if (this._heartbeatsCache?.heartbeats == null) {
2177                    this._heartbeatsCache = await this._heartbeatsCachePromise;
2178                    // If we failed to construct a heartbeats cache, then return immediately.
2179                    if (this._heartbeatsCache?.heartbeats == null) {
2180                        return;
2181                    }
2182                }
2183                // Do not store a heartbeat if one is already stored for this day
2184                // or if a header has already been sent today.
2185                if (this._heartbeatsCache.lastSentHeartbeatDate === date ||
2186                    this._heartbeatsCache.heartbeats.some(singleDateHeartbeat => singleDateHeartbeat.date === date)) {
2187                    return;
2188                }
2189                else {
2190                    // There is no entry for this date. Create one.
2191                    this._heartbeatsCache.heartbeats.push({ date, agent });
2192                    // If the number of stored heartbeats exceeds the maximum number of stored heartbeats, remove the heartbeat with the earliest date.
2193                    // 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.
2194                    if (this._heartbeatsCache.heartbeats.length > MAX_NUM_STORED_HEARTBEATS) {
2195                        const earliestHeartbeatIdx = getEarliestHeartbeatIdx(this._heartbeatsCache.heartbeats);
2196                        this._heartbeatsCache.heartbeats.splice(earliestHeartbeatIdx, 1);
2197                    }
2198                }
2199                return this._storage.overwrite(this._heartbeatsCache);
2200            }
2201            catch (e) {
2202                logger.warn(e);
2203            }
2204        }
2205        /**
2206         * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly.
2207         * It also clears all heartbeats from memory as well as in IndexedDB.
2208         *
2209         * NOTE: Consuming product SDKs should not send the header if this method
2210         * returns an empty string.
2211         */
2212        async getHeartbeatsHeader() {
2213            try {
2214                if (this._heartbeatsCache === null) {
2215                    await this._heartbeatsCachePromise;
2216                }
2217                // If it's still null or the array is empty, there is no data to send.
2218                if (this._heartbeatsCache?.heartbeats == null ||
2219                    this._heartbeatsCache.heartbeats.length === 0) {
2220                    return '';
2221                }
2222                const date = getUTCDateString();
2223                // Extract as many heartbeats from the cache as will fit under the size limit.
2224                const { heartbeatsToSend, unsentEntries } = extractHeartbeatsForHeader(this._heartbeatsCache.heartbeats);
2225                const headerString = base64urlEncodeWithoutPadding(JSON.stringify({ version: 2, heartbeats: heartbeatsToSend }));
2226                // Store last sent date to prevent another being logged/sent for the same day.
2227                this._heartbeatsCache.lastSentHeartbeatDate = date;
2228                if (unsentEntries.length > 0) {
2229                    // Store any unsent entries if they exist.
2230                    this._heartbeatsCache.heartbeats = unsentEntries;
2231                    // This seems more likely than emptying the array (below) to lead to some odd state
2232                    // since the cache isn't empty and this will be called again on the next request,
2233                    // and is probably safest if we await it.
2234                    await this._storage.overwrite(this._heartbeatsCache);
2235                }
2236                else {
2237                    this._heartbeatsCache.heartbeats = [];
2238                    // Do not wait for this, to reduce latency.
2239                    void this._storage.overwrite(this._heartbeatsCache);
2240                }
2241                return headerString;
2242            }
2243            catch (e) {
2244                logger.warn(e);
2245                return '';
2246            }
2247        }
2248    }
2249    function getUTCDateString() {
2250        const today = new Date();
2251        // Returns date format 'YYYY-MM-DD'
2252        return today.toISOString().substring(0, 10);
2253    }
2254    function extractHeartbeatsForHeader(heartbeatsCache, maxSize = MAX_HEADER_BYTES) {
2255        // Heartbeats grouped by user agent in the standard format to be sent in
2256        // the header.
2257        const heartbeatsToSend = [];
2258        // Single date format heartbeats that are not sent.
2259        let unsentEntries = heartbeatsCache.slice();
2260        for (const singleDateHeartbeat of heartbeatsCache) {
2261            // Look for an existing entry with the same user agent.
2262            const heartbeatEntry = heartbeatsToSend.find(hb => hb.agent === singleDateHeartbeat.agent);
2263            if (!heartbeatEntry) {
2264                // If no entry for this user agent exists, create one.
2265                heartbeatsToSend.push({
2266                    agent: singleDateHeartbeat.agent,
2267                    dates: [singleDateHeartbeat.date]
2268                });
2269                if (countBytes(heartbeatsToSend) > maxSize) {
2270                    // If the header would exceed max size, remove the added heartbeat
2271                    // entry and stop adding to the header.
2272                    heartbeatsToSend.pop();
2273                    break;
2274                }
2275            }
2276            else {
2277                heartbeatEntry.dates.push(singleDateHeartbeat.date);
2278                // If the header would exceed max size, remove the added date
2279                // and stop adding to the header.
2280                if (countBytes(heartbeatsToSend) > maxSize) {
2281                    heartbeatEntry.dates.pop();
2282                    break;
2283                }
2284            }
2285            // Pop unsent entry from queue. (Skipped if adding the entry exceeded
2286            // quota and the loop breaks early.)
2287            unsentEntries = unsentEntries.slice(1);
2288        }
2289        return {
2290            heartbeatsToSend,
2291            unsentEntries
2292        };
2293    }
2294    class HeartbeatStorageImpl {
2295        constructor(app) {
2296            this.app = app;
2297            this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();
2298        }
2299        async runIndexedDBEnvironmentCheck() {
2300            if (!isIndexedDBAvailable()) {
2301                return false;
2302            }
2303            else {
2304                return validateIndexedDBOpenable()
2305                    .then(() => true)
2306                    .catch(() => false);
2307            }
2308        }
2309        /**
2310         * Read all heartbeats.
2311         */
2312        async read() {
2313            const canUseIndexedDB = await this._canUseIndexedDBPromise;
2314            if (!canUseIndexedDB) {
2315                return { heartbeats: [] };
2316            }
2317            else {
2318                const idbHeartbeatObject = await readHeartbeatsFromIndexedDB(this.app);
2319                if (idbHeartbeatObject?.heartbeats) {
2320                    return idbHeartbeatObject;
2321                }
2322                else {
2323                    return { heartbeats: [] };
2324                }
2325            }
2326        }
2327        // overwrite the storage with the provided heartbeats
2328        async overwrite(heartbeatsObject) {
2329            const canUseIndexedDB = await this._canUseIndexedDBPromise;
2330            if (!canUseIndexedDB) {
2331                return;
2332            }
2333            else {
2334                const existingHeartbeatsObject = await this.read();
2335                return writeHeartbeatsToIndexedDB(this.app, {
2336                    lastSentHeartbeatDate: heartbeatsObject.lastSentHeartbeatDate ??
2337                        existingHeartbeatsObject.lastSentHeartbeatDate,
2338                    heartbeats: heartbeatsObject.heartbeats
2339                });
2340            }
2341        }
2342        // add heartbeats
2343        async add(heartbeatsObject) {
2344            const canUseIndexedDB = await this._canUseIndexedDBPromise;
2345            if (!canUseIndexedDB) {
2346                return;
2347            }
2348            else {
2349                const existingHeartbeatsObject = await this.read();
2350                return writeHeartbeatsToIndexedDB(this.app, {
2351                    lastSentHeartbeatDate: heartbeatsObject.lastSentHeartbeatDate ??
2352                        existingHeartbeatsObject.lastSentHeartbeatDate,
2353                    heartbeats: [
2354                        ...existingHeartbeatsObject.heartbeats,
2355                        ...heartbeatsObject.heartbeats
2356                    ]
2357                });
2358            }
2359        }
2360    }
2361    /**
2362     * Calculate bytes of a HeartbeatsByUserAgent array after being wrapped
2363     * in a platform logging header JSON object, stringified, and converted
2364     * to base 64.
2365     */
2366    function countBytes(heartbeatsCache) {
2367        // base64 has a restricted set of characters, all of which should be 1 byte.
2368        return base64urlEncodeWithoutPadding(
2369        // heartbeatsCache wrapper properties
2370        JSON.stringify({ version: 2, heartbeats: heartbeatsCache })).length;
2371    }
2372    /**
2373     * Returns the index of the heartbeat with the earliest date.
2374     * If the heartbeats array is empty, -1 is returned.
2375     */
2376    function getEarliestHeartbeatIdx(heartbeats) {
2377        if (heartbeats.length === 0) {
2378            return -1;
2379        }
2380        let earliestHeartbeatIdx = 0;
2381        let earliestHeartbeatDate = heartbeats[0].date;
2382        for (let i = 1; i < heartbeats.length; i++) {
2383            if (heartbeats[i].date < earliestHeartbeatDate) {
2384                earliestHeartbeatDate = heartbeats[i].date;
2385                earliestHeartbeatIdx = i;
2386            }
2387        }
2388        return earliestHeartbeatIdx;
2389    }
2390
2391    /**
2392     * @license
2393     * Copyright 2019 Google LLC
2394     *
2395     * Licensed under the Apache License, Version 2.0 (the "License");

2502);
2503    }
2504
2505    /**
2506     * @license
2507     * Copyright 2019 Google LLC
2508     *
2509     * Licensed under the Apache License, Version 2.0 (the "License");
2510     * you may not use this file except in compliance with the License.
2511     * You may obtain a copy of the License at
2512     *
2513     *   http://www.apache.org/licenses/LICENSE-2.0
2514     *
2515     * Unless required by applicable law or agreed to in writing, software
2516     * distributed under the License is distributed on an "AS IS" BASIS,
2517     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2518     * See the License for the specific language governing permissions and
2519     * limitations under the License.
2520     */
2521    function getInstallationsEndpoint({ projectId }) {
2522        return `${INSTALLATIONS_API_URL}/projects/${projectId}/installations`;
2523    }
2524    function extractAuthTokenInfoFromResponse(response) {
2525        return {
2526            token: response.token,
2527            requestStatus: 2 /* RequestStatus.COMPLETED */,
2528            expiresIn: getExpiresInFromResponseExpiresIn(response.expiresIn),
2529            creationTime: Date.now()
2530        };
2531    }
2532    async function getErrorFromResponse(requestName, response) {
2533        const responseJson = await response.json();
2534        const errorData = responseJson.error;
2535        return ERROR_FACTORY$1.create("request-failed" /* ErrorCode.REQUEST_FAILED */, {
2536            requestName,
2537            serverCode: errorData.code,
2538            serverMessage: errorData.message,
2539            serverStatus: errorData.status
2540        });
2541    }
2542    function getHeaders$1({ apiKey }) {
2543        return new Headers({
2544            'Content-Type': 'application/json',
2545            Accept: 'application/json',
2546            'x-goog-api-key': apiKey
2547        });
2548    }
2549    function getHeadersWithAuth(appConfig, { refreshToken }) {
2550        const headers = getHeaders$1(appConfig);
2551        headers.append('Authorization', getAuthorizationHeader(refreshToken));
2552        return headers;
2553    }
2554    /**
2555     * Calls the passed in fetch wrapper and returns the response.
2556     * If the returned response has a status of 5xx, re-runs the function once and
2557     * returns the response.
2558     */
2559    async function retryIfServerError(fn) {
2560        const result = await fn();
2561        if (result.status >= 500 && result.status < 600) {
2562            // Internal Server Error. Retry request.
2563            return fn();
2564        }
2565        return result;
2566    }
2567    function getExpiresInFromResponseExpiresIn(responseExpiresIn) {
2568        // This works because the server will never respond with fractions of a second.
2569        return Number(responseExpiresIn.replace('s', '000'));
2570    }
2571    function getAuthorizationHeader(refreshToken) {
2572        return `${INTERNAL_AUTH_VERSION} ${refreshToken}`;
2573    }
2574
2575    /**
2576     * @license
2577     * Copyright 2019 Google LLC
2578     *
2579     * Licensed under the Apache License, Version 2.0 (the "License");
2580     * you may not use this file except in compliance with the License.
2581     * You may obtain a copy of the License at
2582     *
2583     *   http://www.apache.org/licenses/LICENSE-2.0
2584     *
2585     * Unless required by applicable law or agreed to in writing, software
2586     * distributed under the License is distributed on an "AS IS" BASIS,
2587     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2588     * See the License for the specific language governing permissions and
2589     * limitations under the License.
2590     */
2591    async function createInstallationRequest({ appConfig, heartbeatServiceProvider }, { fid }) {
2592        const endpoint = getInstallationsEndpoint(appConfig);
2593        const headers = getHeaders$1(appConfig);
2594        // If heartbeat service exists, add the heartbeat string to the header.
2595        const heartbeatService = heartbeatServiceProvider.getImmediate({
2596            optional: true
2597        });
2598        if (heartbeatService) {
2599            const heartbeatsHeader = await heartbeatService.getHeartbeatsHeader();
2600            if (heartbeatsHeader) {
2601                headers.append('x-firebase-client', heartbeatsHeader);
2602            }
2603        }
2604        const body = {
2605            fid,
2606            authVersion: INTERNAL_AUTH_VERSION,
2607            appId: appConfig.appId,
2608            sdkVersion: PACKAGE_VERSION
2609        };
2610        const request = {
2611            method: 'POST',
2612            headers,
2613            body: JSON.stringify(body)
2614        };
2615        const response = await retryIfServerError(() => fetch(endpoint, request));
2616        if (response.ok) {
2617            const responseValue = await response.json();
2618            const registeredInstallationEntry = {
2619                fid: responseValue.fid || fid,
2620                registrationStatus: 2 /* RequestStatus.COMPLETED */,
2621                refreshToken: responseValue.refreshToken,
2622                authToken: extractAuthTokenInfoFromResponse(responseValue.authToken)
2623            };
2624            return registeredInstallationEntry;
2625        }
2626        else {
2627            throw await getErrorFromResponse('Create Installation', response);
2628        }
2629    }
2630
2631    /**
2632     * @license
2633     * Copyright 2019 Google LLC
2634     *
2635     * Licensed under the Apache License, Version 2.0 (the "License");
2636     * you may not use this file except in compliance with the License.
2637     * You may obtain a copy of the License at
2638     *
2639     *   http://www.apache.org/licenses/LICENSE-2.0
2640     *
2641     * Unless required by applicable law or agreed to in writing, software
2642     * distributed under the License is distributed on an "AS IS" BASIS,
2643     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2644     * See the License for the specific language governing permissions and
2645     * limitations under the License.
2646     */
2647    /** Returns a promise that resolves after given time passes. */
2648    function sleep$1(ms) {
2649        return new Promise(resolve => {
2650            setTimeout(resolve, ms);
2651        });
2652    }
2653
2654    /**
2655     * @license
2656     * Copyright 2019 Google LLC
2657     *
2658     * Licensed under the Apache License, Version 2.0 (the "License");
2659     * you may not use this file except in compliance with the License.
2660     * You may obtain a copy of the License at
2661     *
2662     *   http://www.apache.org/licenses/LICENSE-2.0
2663     *
2664     * Unless required by applicable law or agreed to in writing, software
2665     * distributed under the License is distributed on an "AS IS" BASIS,
2666     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2667     * See the License for the specific language governing permissions and
2668     * limitations under the License.
2669     */
2670    function bufferToBase64UrlSafe(array) {
2671        const b64 = btoa(String.fromCharCode(...array));
2672        return b64.replace(/\+/g, '-').replace(/\//g, '_');
2673    }
2674
2675    /**
2676     * @license
2677     * Copyright 2019 Google LLC
2678     *
2679     * Licensed under the Apache License, Version 2.0 (the "License");
2680     * you may not use this file except in compliance with the License.
2681     * You may obtain a copy of the License at
2682     *
2683     *   http://www.apache.org/licenses/LICENSE-2.0
2684     *
2685     * Unless required by applicable law or agreed to in writing, software
2686     * distributed under the License is distributed on an "AS IS" BASIS,
2687     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2688     * See the License for the specific language governing permissions and
2689     * limitations under the License.
2690     */
2691    const VALID_FID_PATTERN = /^[cdef][\w-]{21}$/;
2692    const INVALID_FID = '';
2693    /**
2694     * Generates a new FID using random values from Web Crypto API.
2695     * Returns an empty string if FID generation fails for any reason.
2696     */
2697    function generateFid() {
2698        try {
2699            // A valid FID has exactly 22 base64 characters, which is 132 bits, or 16.5
2700            // bytes. our implementation generates a 17 byte array instead.
2701            const fidByteArray = new Uint8Array(17);
2702            const crypto = self.crypto || self.msCrypto;
2703            crypto.getRandomValues(fidByteArray);
2704            // Replace the first 4 random bits with the constant FID header of 0b0111.
2705            fidByteArray[0] = 0b01110000 + (fidByteArray[0] % 0b00010000);
2706            const fid = encode(fidByteArray);
2707            return VALID_FID_PATTERN.test(fid) ? fid : INVALID_FID;
2708        }
2709        catch {
2710            // FID generation errored
2711            return INVALID_FID;
2712        }
2713    }
2714    /** Converts a FID Uint8Array to a base64 string representation. */
2715    function encode(fidByteArray) {
2716        const b64String = bufferToBase64UrlSafe(fidByteArray);
2717        // Remove the 23rd character that was added because of the extra 4 bits at the
2718        // end of our 17 byte array, and the '=' padding.
2719        return b64String.substr(0, 22);
2720    }
2721
2722    /**
2723     * @license
2724     * Copyright 2019 Google LLC
2725     *
2726     * Licensed under the Apache License, Version 2.0 (the "License");