https://iolingjapan.org/js/firebase-initialize.js

21// node_modules/tslib/tslib.js
22  var require_tslib = __commonJS({
23    "node_modules/tslib/tslib.js"(exports, module) {
24      var __extends2;
25      var __assign2;
26      var __rest2;
27      var __decorate2;
28      var __param2;
29      var __metadata2;
30      var __awaiter2;
31      var __generator2;
32      var __exportStar2;
33      var __values2;
34      var __read2;
35      var __spread2;
36      var __spreadArrays2;
37      var __spreadArray2;
38      var __await2;
39      var __asyncGenerator2;
40      var __asyncDelegator2;
41      var __asyncValues2;
42      var __makeTemplateObject2;
43      var __importStar2;
44      var __importDefault2;
45      var __classPrivateFieldGet2;
46      var __classPrivateFieldSet2;
47      var __classPrivateFieldIn2;
48      var __createBinding2;
49      (function(factory2) {
50        var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {};
51        if (typeof define === "function" && define.amd) {
52          define("tslib", ["exports"], function(exports2) {
53            factory2(createExporter(root, createExporter(exports2)));
54          });
55        } else if (typeof module === "object" && typeof module.exports === "object") {
56          factory2(createExporter(root, createExporter(module.exports)));
57        } else {
58          factory2(createExporter(root));
59        }
60        function createExporter(exports2, previous) {
61          if (exports2 !== root) {
62            if (typeof Object.create === "function") {
63              Object.defineProperty(exports2, "__esModule", { value: true });
64            } else {
65              exports2.__esModule = true;
66            }
67          }
68          return function(id, v) {
69            return exports2[id] = previous ? previous(id, v) : v;
70          };
71        }
72      })(function(exporter) {
73        var extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
74          d.__proto__ = b;
75        } || function(d, b) {
76          for (var p in b)
77            if (Object.prototype.hasOwnProperty.call(b, p))
78              d[p] = b[p];
79        };
80        __extends2 = function(d, b) {
81          if (typeof b !== "function" && b !== null)
82            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
83          extendStatics(d, b);
84          function __() {
85            this.constructor = d;
86          }
87          d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
88        };
89        __assign2 = Object.assign || function(t) {
90          for (var s, i = 1, n = arguments.length; i < n; i++) {
91            s = arguments[i];
92            for (var p in s)
93              if (Object.prototype.hasOwnProperty.call(s, p))
94                t[p] = s[p];
95          }
96          return t;
97        };
98        __rest2 = function(s, e) {
99          var t = {};
100          for (var p in s)
101            if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
102              t[p] = s[p];
103          if (s != null && typeof Object.getOwnPropertySymbols === "function")
104            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
105              if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
106                t[p[i]] = s[p[i]];
107            }
108          return t;
109        };
110        __decorate2 = function(decorators, target, key, desc) {
111          var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
112          if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
113            r = Reflect.decorate(decorators, target, key, desc);
114          else
115            for (var i = decorators.length - 1; i >= 0; i--)
116              if (d = decorators[i])
117                r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
118          return c > 3 && r && Object.defineProperty(target, key, r), r;
119        };
120        __param2 = function(paramIndex, decorator) {
121          return function(target, key) {
122            decorator(target, key, paramIndex);
123          };
124        };
125        __metadata2 = function(metadataKey, metadataValue) {
126          if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
127            return Reflect.metadata(metadataKey, metadataValue);
128        };
129        __awaiter2 = function(thisArg, _arguments, P, generator) {
130          function adopt(value) {
131            return value instanceof P ? value : new P(function(resolve) {
132              resolve(value);
133            });
134          }
135          return new (P || (P = Promise))(function(resolve, reject) {
136            function fulfilled(value) {
137              try {
138                step(generator.next(value));
139              } catch (e) {
140                reject(e);
141              }
142            }
143            function rejected(value) {
144              try {
145                step(generator["throw"](value));
146              } catch (e) {
147                reject(e);
148              }
149            }
150            function step(result) {
151              result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
152            }
153            step((generator = generator.apply(thisArg, _arguments || [])).next());
154          });
155        };
156        __generator2 = function(thisArg, body) {
157          var _ = { label: 0, sent: function() {
158            if (t[0] & 1)
159              throw t[1];
160            return t[1];
161          }, trys: [], ops: [] }, f, y, t, g;
162          return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
163            return this;
164          }), g;
165          function verb(n) {
166            return function(v) {
167              return step([n, v]);
168            };
169          }
170          function step(op) {
171            if (f)
172              throw new TypeError("Generator is already executing.");
173            while (_)
174              try {
175                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
176                  return t;
177                if (y = 0, t)
178                  op = [op[0] & 2, t.value];
179                switch (op[0]) {
180                  case 0:
181                  case 1:
182                    t = op;
183                    break;
184                  case 4:
185                    _.label++;
186                    return { value: op[1], done: false };
187                  case 5:
188                    _.label++;
189                    y = op[1];
190                    op = [0];
191                    continue;
192                  case 7:
193                    op = _.ops.pop();
194                    _.trys.pop();
195                    continue;
196                  default:
197                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
198                      _ = 0;
199                      continue;
200                    }
201                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
202                      _.label = op[1];
203                      break;
204                    }
205                    if (op[0] === 6 && _.label < t[1]) {
206                      _.label = t[1];
207                      t = op;
208                      break;
209                    }
210                    if (t && _.label < t[2]) {
211                      _.label = t[2];
212                      _.ops.push(op);
213                      break;
214                    }
215                    if (t[2])
216                      _.ops.pop();
217                    _.trys.pop();
218                    continue;
219                }
220                op = body.call(thisArg, _);
221              } catch (e) {
222                op = [6, e];
223                y = 0;
224              } finally {
225                f = t = 0;
226              }
227            if (op[0] & 5)
228              throw op[1];
229            return { value: op[0] ? op[1] : void 0, done: true };
230          }
231        };
232        __exportStar2 = function(m, o) {
233          for (var p in m)
234            if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
235              __createBinding2(o, m, p);
236        };
237        __createBinding2 = Object.create ? function(o, m, k, k2) {
238          if (k2 === void 0)
239            k2 = k;
240          var desc = Object.getOwnPropertyDescriptor(m, k);
241          if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
242            desc = { enumerable: true, get: function() {
243              return m[k];
244            } };
245          }
246          Object.defineProperty(o, k2, desc);
247        } : function(o, m, k, k2) {
248          if (k2 === void 0)
249            k2 = k;
250          o[k2] = m[k];
251        };
252        __values2 = function(o) {
253          var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
254          if (m)
255            return m.call(o);
256          if (o && typeof o.length === "number")
257            return {
258              next: function() {
259                if (o && i >= o.length)
260                  o = void 0;
261                return { value: o && o[i++], done: !o };
262              }
263            };
264          throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
265        };
266        __read2 = function(o, n) {
267          var m = typeof Symbol === "function" && o[Symbol.iterator];
268          if (!m)
269            return o;
270          var i = m.call(o), r, ar = [], e;
271          try {
272            while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
273              ar.push(r.value);
274          } catch (error2) {
275            e = { error: error2 };
276          } finally {
277            try {
278              if (r && !r.done && (m = i["return"]))
279                m.call(i);
280            } finally {
281              if (e)
282                throw e.error;
283            }
284          }
285          return ar;
286        };
287        __spread2 = function() {
288          for (var ar = [], i = 0; i < arguments.length; i++)
289            ar = ar.concat(__read2(arguments[i]));
290          return ar;
291        };
292        __spreadArrays2 = function() {
293          for (var s = 0, i = 0, il = arguments.length; i < il; i++)
294            s += arguments[i].length;
295          for (var r = Array(s), k = 0, i = 0; i < il; i++)
296            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
297              r[k] = a[j];
298          return r;
299        };
300        __spreadArray2 = function(to, from, pack) {
301          if (pack || arguments.length === 2)
302            for (var i = 0, l = from.length, ar; i < l; i++) {
303              if (ar || !(i in from)) {
304                if (!ar)
305                  ar = Array.prototype.slice.call(from, 0, i);
306                ar[i] = from[i];
307              }
308            }
309          return to.concat(ar || Array.prototype.slice.call(from));
310        };
311        __await2 = function(v) {
312          return this instanceof __await2 ? (this.v = v, this) : new __await2(v);
313        };
314        __asyncGenerator2 = function(thisArg, _arguments, generator) {
315          if (!Symbol.asyncIterator)
316            throw new TypeError("Symbol.asyncIterator is not defined.");
317          var g = generator.apply(thisArg, _arguments || []), i, q = [];
318          return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
319            return this;
320          }, i;
321          function verb(n) {
322            if (g[n])
323              i[n] = function(v) {
324                return new Promise(function(a, b) {
325                  q.push([n, v, a, b]) > 1 || resume(n, v);
326                });
327              };
328          }
329          function resume(n, v) {
330            try {
331              step(g[n](v));
332            } catch (e) {
333              settle(q[0][3], e);
334            }
335          }
336          function step(r) {
337            r.value instanceof __await2 ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
338          }
339          function fulfill(value) {
340            resume("next", value);
341          }
342          function reject(value) {
343            resume("throw", value);
344          }
345          function settle(f, v) {
346            if (f(v), q.shift(), q.length)
347              resume(q[0][0], q[0][1]);
348          }
349        };
350        __asyncDelegator2 = function(o) {
351          var i, p;
352          return i = {}, verb("next"), verb("throw", function(e) {
353            throw e;
354          }), verb("return"), i[Symbol.iterator] = function() {
355            return this;
356          }, i;
357          function verb(n, f) {
358            i[n] = o[n] ? function(v) {
359              return (p = !p) ? { value: __await2(o[n](v)), done: n === "return" } : f ? f(v) : v;
360            } : f;
361          }
362        };
363        __asyncValues2 = function(o) {
364          if (!Symbol.asyncIterator)
365            throw new TypeError("Symbol.asyncIterator is not defined.");
366          var m = o[Symbol.asyncIterator], i;
367          return m ? m.call(o) : (o = typeof __values2 === "function" ? __values2(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
368            return this;
369          }, i);
370          function verb(n) {
371            i[n] = o[n] && function(v) {
372              return new Promise(function(resolve, reject) {
373                v = o[n](v), settle(resolve, reject, v.done, v.value);
374              });
375            };
376          }
377          function settle(resolve, reject, d, v) {
378            Promise.resolve(v).then(function(v2) {
379              resolve({ value: v2, done: d });
380            }, reject);
381          }
382        };
383        __makeTemplateObject2 = function(cooked, raw) {
384          if (Object.defineProperty) {
385            Object.defineProperty(cooked, "raw", { value: raw });
386          } else {
387            cooked.raw = raw;
388          }
389          return cooked;
390        };
391        var __setModuleDefault = Object.create ? function(o, v) {
392          Object.defineProperty(o, "default", { enumerable: true, value: v });
393        } : function(o, v) {
394          o["default"] = v;
395        };
396        __importStar2 = function(mod) {
397          if (mod && mod.__esModule)
398            return mod;
399          var result = {};
400          if (mod != null) {
401            for (var k in mod)
402              if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
403                __createBinding2(result, mod, k);
404          }
405          __setModuleDefault(result, mod);
406          return result;
407        };
408        __importDefault2 = function(mod) {
409          return mod && mod.__esModule ? mod : { "default": mod };
410        };
411        __classPrivateFieldGet2 = function(receiver, state, kind, f) {
412          if (kind === "a" && !f)
413            throw new TypeError("Private accessor was defined without a getter");
414          if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
415            throw new TypeError("Cannot read private member from an object whose class did not declare it");
416          return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
417        };
418        __classPrivateFieldSet2 = function(receiver, state, value, kind, f) {
419          if (kind === "m")
420            throw new TypeError("Private method is not writable");
421          if (kind === "a" && !f)
422            throw new TypeError("Private accessor was defined without a setter");
423          if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
424            throw new TypeError("Cannot write private member to an object whose class did not declare it");
425          return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
426        };
427        __classPrivateFieldIn2 = function(state, receiver) {
428          if (receiver === null || typeof receiver !== "object" && typeof receiver !== "function")
429            throw new TypeError("Cannot use 'in' operator on non-object");
430          return typeof state === "function" ? receiver === state : state.has(receiver);
431        };
432        exporter("__extends", __extends2);
433        exporter("__assign", __assign2);
434        exporter("__rest", __rest2);
435        exporter("__decorate", __decorate2);
436        exporter("__param", __param2);
437        exporter("__metadata", __metadata2);
438        exporter("__awaiter", __awaiter2);
439        exporter("__generator", __generator2);
440        exporter("__exportStar", __exportStar2);
441        exporter("__createBinding", __createBinding2);
442        exporter("__values", __values2);
443        exporter("__read", __read2);
444        exporter("__spread", __spread2);
445        exporter("__spreadArrays", __spreadArrays2);
446        exporter("__spreadArray", __spreadArray2);
447        exporter("__await", __await2);
448        exporter("__asyncGenerator", __asyncGenerator2);
449        exporter("__asyncDelegator", __asyncDelegator2);
450        exporter("__asyncValues", __asyncValues2);
451        exporter("__makeTemplateObject", __makeTemplateObject2);
452        exporter("__importStar", __importStar2);
453        exporter("__importDefault", __importDefault2);
454        exporter("__classPrivateFieldGet", __classPrivateFieldGet2);
455        exporter("__classPrivateFieldSet", __classPrivateFieldSet2);
456        exporter("__classPrivateFieldIn", __classPrivateFieldIn2);
457      });
458    }
459  });
460
461  

461// node_modules/@firebase/util/dist/index.esm2017.js
462  var CONSTANTS = {
463    NODE_CLIENT: false,
464    NODE_ADMIN: false,
465    SDK_VERSION: "${JSCORE_VERSION}"
466  };
467  var assert = function(assertion, message) {
468    if (!assertion) {
469      throw assertionError(message);
470    }
471  };
472  var assertionError = function(message) {
473    return new Error("Firebase Database (" + CONSTANTS.SDK_VERSION + ") INTERNAL ASSERT FAILED: " + message);
474  };
475  var stringToByteArray$1 = function(str) {
476    const out = [];
477    let p = 0;
478    for (let i = 0; i < str.length; i++) {
479      let c = str.charCodeAt(i);
480      if (c < 128) {
481        out[p++] = c;
482      } else if (c < 2048) {
483        out[p++] = c >> 6 | 192;
484        out[p++] = c & 63 | 128;
485      } else if ((c & 64512) === 55296 && i + 1 < str.length && (str.charCodeAt(i + 1) & 64512) === 56320) {
486        c = 65536 + ((c & 1023) << 10) + (str.charCodeAt(++i) & 1023);
487        out[p++] = c >> 18 | 240;
488        out[p++] = c >> 12 & 63 | 128;
489        out[p++] = c >> 6 & 63 | 128;
490        out[p++] = c & 63 | 128;
491      } else {
492        out[p++] = c >> 12 | 224;
493        out[p++] = c >> 6 & 63 | 128;
494        out[p++] = c & 63 | 128;
495      }
496    }
497    return out;
498  };
499  var byteArrayToString = function(bytes) {
500    const out = [];
501    let pos = 0, c = 0;
502    while (pos < bytes.length) {
503      const c1 = bytes[pos++];
504      if (c1 < 128) {
505        out[c++] = String.fromCharCode(c1);
506      } else if (c1 > 191 && c1 < 224) {
507        const c2 = bytes[pos++];
508        out[c++] = String.fromCharCode((c1 & 31) << 6 | c2 & 63);
509      } else if (c1 > 239 && c1 < 365) {
510        const c2 = bytes[pos++];
511        const c3 = bytes[pos++];
512        const c4 = bytes[pos++];
513        const u = ((c1 & 7) << 18 | (c2 & 63) << 12 | (c3 & 63) << 6 | c4 & 63) - 65536;
514        out[c++] = String.fromCharCode(55296 + (u >> 10));
515        out[c++] = String.fromCharCode(56320 + (u & 1023));
516      } else {
517        const c2 = bytes[pos++];
518        const c3 = bytes[pos++];
519        out[c++] = String.fromCharCode((c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63);
520      }
521    }
522    return out.join("");
523  };
524  var base64 = {
525    byteToCharMap_: null,
526    charToByteMap_: null,
527    byteToCharMapWebSafe_: null,
528    charToByteMapWebSafe_: null,
529    ENCODED_VALS_BASE: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
530    get ENCODED_VALS() {
531      return this.ENCODED_VALS_BASE + "+/=";
532    },
533    get ENCODED_VALS_WEBSAFE() {
534      return this.ENCODED_VALS_BASE + "-_.";
535    },
536    HAS_NATIVE_SUPPORT: typeof atob === "function",
537    encodeByteArray(input, webSafe) {
538      if (!Array.isArray(input)) {
539        throw Error("encodeByteArray takes an array as a parameter");
540      }
541      this.init_();
542      const byteToCharMap = webSafe ? this.byteToCharMapWebSafe_ : this.byteToCharMap_;
543      const output = [];
544      for (let i = 0; i < input.length; i += 3) {
545        const byte1 = input[i];
546        const haveByte2 = i + 1 < input.length;
547        const byte2 = haveByte2 ? input[i + 1] : 0;
548        const haveByte3 = i + 2 < input.length;
549        const byte3 = haveByte3 ? input[i + 2] : 0;
550        const outByte1 = byte1 >> 2;
551        const outByte2 = (byte1 & 3) << 4 | byte2 >> 4;
552        let outByte3 = (byte2 & 15) << 2 | byte3 >> 6;
553        let outByte4 = byte3 & 63;
554        if (!haveByte3) {
555          outByte4 = 64;
556          if (!haveByte2) {
557            outByte3 = 64;
558          }
559        }
560        output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);
561      }
562      return output.join("");
563    },
564    encodeString(input, webSafe) {
565      if (this.HAS_NATIVE_SUPPORT && !webSafe) {
566        return btoa(input);
567      }
568      return this.encodeByteArray(stringToByteArray$1(input), webSafe);
569    },
570    decodeString(input, webSafe) {
571      if (this.HAS_NATIVE_SUPPORT && !webSafe) {
572        return atob(input);
573      }
574      return byteArrayToString(this.decodeStringToByteArray(input, webSafe));
575    },
576    decodeStringToByteArray(input, webSafe) {
577      this.init_();
578      const charToByteMap = webSafe ? this.charToByteMapWebSafe_ : this.charToByteMap_;
579      const output = [];
580      for (let i = 0; i < input.length; ) {
581        const byte1 = charToByteMap[input.charAt(i++)];
582        const haveByte2 = i < input.length;
583        const byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;
584        ++i;
585        const haveByte3 = i < input.length;
586        const byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;
587        ++i;
588        const haveByte4 = i < input.length;
589        const byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;
590        ++i;
591        if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {
592          throw Error();
593        }
594        const outByte1 = byte1 << 2 | byte2 >> 4;
595        output.push(outByte1);
596        if (byte3 !== 64) {
597          const outByte2 = byte2 << 4 & 240 | byte3 >> 2;
598          output.push(outByte2);
599          if (byte4 !== 64) {
600            const outByte3 = byte3 << 6 & 192 | byte4;
601            output.push(outByte3);
602          }
603        }
604      }
605      return output;
606    },
607    init_() {
608      if (!this.byteToCharMap_) {
609        this.byteToCharMap_ = {};
610        this.charToByteMap_ = {};
611        this.byteToCharMapWebSafe_ = {};
612        this.charToByteMapWebSafe_ = {};
613        for (let i = 0; i < this.ENCODED_VALS.length; i++) {
614          this.byteToCharMap_[i] = this.ENCODED_VALS.charAt(i);
615          this.charToByteMap_[this.byteToCharMap_[i]] = i;
616          this.byteToCharMapWebSafe_[i] = this.ENCODED_VALS_WEBSAFE.charAt(i);
617          this.charToByteMapWebSafe_[this.byteToCharMapWebSafe_[i]] = i;
618          if (i >= this.ENCODED_VALS_BASE.length) {
619            this.charToByteMap_[this.ENCODED_VALS_WEBSAFE.charAt(i)] = i;
620            this.charToByteMapWebSafe_[this.ENCODED_VALS.charAt(i)] = i;
621          }
622        }
623      }
624    }
625  };
626  var base64Encode = function(str) {
627    const utf8Bytes = stringToByteArray$1(str);
628    return base64.encodeByteArray(utf8Bytes, true);
629  };
630  var base64urlEncodeWithoutPadding = function(str) {
631    return base64Encode(str).replace(/\./g, "");
632  };
633  var base64Decode = function(str) {
634    try {
635      return base64.decodeString(str, true);
636    } catch (e) {
637      console.error("base64Decode failed: ", e);
638    }
639    return null;
640  };
641  function deepCopy(value) {
642    return deepExtend(void 0, value);
643  }
644  function deepExtend(target, source) {
645    if (!(source instanceof Object)) {
646      return source;
647    }
648    switch (source.constructor) {
649      case Date:
650        const dateValue = source;
651        return new Date(dateValue.getTime());
652      case Object:
653        if (target === void 0) {
654          target = {};
655        }
656        break;
657      case Array:
658        target = [];
659        break;
660      default:
661        return source;
662    }
663    for (const prop in source) {
664      if (!source.hasOwnProperty(prop) || !isValidKey(prop)) {
665        continue;
666      }
667      target[prop] = deepExtend(target[prop], source[prop]);
668    }
669    return target;
670  }
671  function isValidKey(key) {
672    return key !== "__proto__";
673  }
674  var Deferred = class {
675    constructor() {
676      this.reject = () => {
677      };
678      this.resolve = () => {
679      };
680      this.promise = new Promise((resolve, reject) => {
681        this.resolve = resolve;
682        this.reject = reject;
683      });
684    }
685    wrapCallback(callback) {
686      return (error2, value) => {
687        if (error2) {
688          this.reject(error2);
689        } else {
690          this.resolve(value);
691        }
692        if (typeof callback === "function") {
693          this.promise.catch(() => {
694          });
695          if (callback.length === 1) {
696            callback(error2);
697          } else {
698            callback(error2, value);
699          }
700        }
701      };
702    }
703  };
704  function getUA() {
705    if (typeof navigator !== "undefined" && typeof navigator["userAgent"] === "string") {
706      return navigator["userAgent"];
707    } else {
708      return "";
709    }
710  }
711  function isMobileCordova() {
712    return typeof window !== "undefined" && !!(window["cordova"] || window["phonegap"] || window["PhoneGap"]) && /ios|iphone|ipod|ipad|android|blackberry|iemobile/i.test(getUA());
713  }
714  function isBrowserExtension() {
715    const runtime = typeof chrome === "object" ? chrome.runtime : typeof browser === "object" ? browser.runtime : void 0;
716    return typeof runtime === "object" && runtime.id !== void 0;
717  }
718  function isReactNative() {
719    return typeof navigator === "object" && navigator["product"] === "ReactNative";
720  }
721  function isIE() {
722    const ua = getUA();
723    return ua.indexOf("MSIE ") >= 0 || ua.indexOf("Trident/") >= 0;
724  }
725  function isNodeSdk() {
726    return CONSTANTS.NODE_CLIENT === true || CONSTANTS.NODE_ADMIN === true;
727  }
728  function isIndexedDBAvailable() {
729    return typeof indexedDB === "object";
730  }
731  function validateIndexedDBOpenable() {
732    return new Promise((resolve, reject) => {
733      try {
734        let preExist = true;
735        const DB_CHECK_NAME = "validate-browser-context-for-indexeddb-analytics-module";
736        const request = self.indexedDB.open(DB_CHECK_NAME);
737        request.onsuccess = () => {
738          request.result.close();
739          if (!preExist) {
740            self.indexedDB.deleteDatabase(DB_CHECK_NAME);
741          }
742          resolve(true);
743        };
744        request.onupgradeneeded = () => {
745          preExist = false;
746        };
747        request.onerror = () => {
748          var _a;
749          reject(((_a = request.error) === null || _a === void 0 ? void 0 : _a.message) || "");
750        };
751      } catch (error2) {
752        reject(error2);
753      }
754    });
755  }
756  function areCookiesEnabled() {
757    if (typeof navigator === "undefined" || !navigator.cookieEnabled) {
758      return false;
759    }
760    return true;
761  }
762  var ERROR_NAME = "FirebaseError";
763  var FirebaseError = class extends Error {
764    constructor(code, message, customData) {
765      super(message);
766      this.code = code;
767      this.customData = customData;
768      this.name = ERROR_NAME;
769      Object.setPrototypeOf(this, FirebaseError.prototype);
770      if (Error.captureStackTrace) {
771        Error.captureStackTrace(this, ErrorFactory.prototype.create);
772      }
773    }
774  };
775  var ErrorFactory = class {
776    constructor(service, serviceName, errors) {
777      this.service = service;
778      this.serviceName = serviceName;
779      this.errors = errors;
780    }
781    create(code, ...data) {
782      const customData = data[0] || {};
783      const fullCode = `${this.service}/${code}`;
784      const template = this.errors[code];
785      const message = template ? replaceTemplate(template, customData) : "Error";
786      const fullMessage = `${this.serviceName}: ${message} (${fullCode}).`;
787      const error2 = new FirebaseError(fullCode, fullMessage, customData);
788      return error2;
789    }
790  };
791  function replaceTemplate(template, data) {
792    return template.replace(PATTERN, (_, key) => {
793      const value = data[key];
794      return value != null ? String(value) : `<${key}?>`;
795    });
796  }
797  var PATTERN = /\{\$([^}]+)}/g;
798  function jsonEval(str) {
799    return JSON.parse(str);
800  }
801  function stringify(data) {
802    return JSON.stringify(data);
803  }
804  var decode = function(token) {
805    let header = {}, claims = {}, data = {}, signature = "";
806    try {
807      const parts = token.split(".");
808      header = jsonEval(base64Decode(parts[0]) || "");
809      claims = jsonEval(base64Decode(parts[1]) || "");
810      signature = parts[2];
811      data = claims["d"] || {};
812      delete claims["d"];
813    } catch (e) {
814    }
815    return {
816      header,
817      claims,
818      data,
819      signature
820    };
821  };
822  var isValidFormat = function(token) {
823    const decoded = decode(token), claims = decoded.claims;
824    return !!claims && typeof claims === "object" && claims.hasOwnProperty("iat");
825  };
826  var isAdmin = function(token) {
827    const claims = decode(token).claims;
828    return typeof claims === "object" && claims["admin"] === true;
829  };
830  function contains(obj, key) {
831    return Object.prototype.hasOwnProperty.call(obj, key);
832  }
833  function safeGet(obj, key) {
834    if (Object.prototype.hasOwnProperty.call(obj, key)) {
835      return obj[key];
836    } else {
837      return void 0;
838    }
839  }
840  function isEmpty(obj) {
841    for (const key in obj) {
842      if (Object.prototype.hasOwnProperty.call(obj, key)) {
843        return false;
844      }
845    }
846    return true;
847  }
848  function map(obj, fn, contextObj) {
849    const res = {};
850    for (const key in obj) {
851      if (Object.prototype.hasOwnProperty.call(obj, key)) {
852        res[key] = fn.call(contextObj, obj[key], key, obj);
853      }
854    }
855    return res;
856  }
857  function deepEqual(a, b) {
858    if (a === b) {
859      return true;
860    }
861    const aKeys = Object.keys(a);
862    const bKeys = Object.keys(b);
863    for (const k of aKeys) {
864      if (!bKeys.includes(k)) {
865        return false;
866      }
867      const aProp = a[k];
868      const bProp = b[k];
869      if (isObject(aProp) && isObject(bProp)) {
870        if (!deepEqual(aProp, bProp)) {
871          return false;
872        }
873      } else if (aProp !== bProp) {
874        return false;
875      }
876    }
877    for (const k of bKeys) {
878      if (!aKeys.includes(k)) {
879        return false;
880      }
881    }
882    return true;
883  }
884  function isObject(thing) {
885    return thing !== null && typeof thing === "object";
886  }
887  function querystring(querystringParams) {
888    const params = [];
889    for (const [key, value] of Object.entries(querystringParams)) {
890      if (Array.isArray(value)) {
891        value.forEach((arrayVal) => {
892          params.push(encodeURIComponent(key) + "=" + encodeURIComponent(arrayVal));
893        });
894      } else {
895        params.push(encodeURIComponent(key) + "=" + encodeURIComponent(value));
896      }
897    }
898    return params.length ? "&" + params.join("&") : "";
899  }
900  function querystringDecode(querystring2) {
901    const obj = {};
902    const tokens = querystring2.replace(/^\?/, "").split("&");
903    tokens.forEach((token) => {
904      if (token) {
905        const [key, value] = token.split("=");
906        obj[decodeURIComponent(key)] = decodeURIComponent(value);
907      }
908    });
909    return obj;
910  }
911  function extractQuerystring(url) {
912    const queryStart = url.indexOf("?");
913    if (!queryStart) {
914      return "";
915    }
916    const fragmentStart = url.indexOf("#", queryStart);
917    return url.substring(queryStart, fragmentStart > 0 ? fragmentStart : void 0);
918  }
919  var Sha1 = class {
920    constructor() {
921      this.chain_ = [];
922      this.buf_ = [];
923      this.W_ = [];
924      this.pad_ = [];
925      this.inbuf_ = 0;
926      this.total_ = 0;
927      this.blockSize = 512 / 8;
928      this.pad_[0] = 128;
929      for (let i = 1; i < this.blockSize; ++i) {
930        this.pad_[i] = 0;
931      }
932      this.reset();
933    }
934    reset() {
935      this.chain_[0] = 1732584193;
936      this.chain_[1] = 4023233417;
937      this.chain_[2] = 2562383102;
938      this.chain_[3] = 271733878;
939      this.chain_[4] = 3285377520;
940      this.inbuf_ = 0;
941      this.total_ = 0;
942    }
943    compress_(buf, offset) {
944      if (!offset) {
945        offset = 0;
946      }
947      const W = this.W_;
948      if (typeof buf === "string") {
949        for (let i = 0; i < 16; i++) {
950          W[i] = buf.charCodeAt(offset) << 24 | buf.charCodeAt(offset + 1) << 16 | buf.charCodeAt(offset + 2) << 8 | buf.charCodeAt(offset + 3);
951          offset += 4;
952        }
953      } else {
954        for (let i = 0; i < 16; i++) {
955          W[i] = buf[offset] << 24 | buf[offset + 1] << 16 | buf[offset + 2] << 8 | buf[offset + 3];
956          offset += 4;
957        }
958      }
959      for (let i = 16; i < 80; i++) {
960        const t = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
961        W[i] = (t << 1 | t >>> 31) & 4294967295;
962      }
963      let a = this.chain_[0];
964      let b = this.chain_[1];
965      let c = this.chain_[2];
966      let d = this.chain_[3];
967      let e = this.chain_[4];
968      let f, k;
969      for (let i = 0; i < 80; i++) {
970        if (i < 40) {
971          if (i < 20) {
972            f = d ^ b & (c ^ d);
973            k = 1518500249;
974          } else {
975            f = b ^ c ^ d;
976            k = 1859775393;
977          }
978        } else {
979          if (i < 60) {
980            f = b & c | d & (b | c);
981            k = 2400959708;
982          } else {
983            f = b ^ c ^ d;
984            k = 3395469782;
985          }
986        }
987        const t = (a << 5 | a >>> 27) + f + e + k + W[i] & 4294967295;
988        e = d;
989        d = c;
990        c = (b << 30 | b >>> 2) & 4294967295;
991        b = a;
992        a = t;
993      }
994      this.chain_[0] = this.chain_[0] + a & 4294967295;
995      this.chain_[1] = this.chain_[1] + b & 4294967295;
996      this.chain_[2] = this.chain_[2] + c & 4294967295;
997      this.chain_[3] = this.chain_[3] + d & 4294967295;
998      this.chain_[4] = this.chain_[4] + e & 4294967295;
999    }
1000    update(bytes, length) {
1001      if (bytes == null) {
1002        return;
1003      }
1004      if (length === void 0) {
1005        length = bytes.length;
1006      }
1007      const lengthMinusBlock = length - this.blockSize;
1008      let n = 0;
1009      const buf = this.buf_;
1010      let inbuf = this.inbuf_;
1011      while (n < length) {
1012        if (inbuf === 0) {
1013          while (n <= lengthMinusBlock) {
1014            this.compress_(bytes, n);
1015            n += this.blockSize;
1016          }
1017        }
1018        if (typeof bytes === "string") {
1019          while (n < length) {
1020            buf[inbuf] = bytes.charCodeAt(n);
1021            ++inbuf;
1022            ++n;
1023            if (inbuf === this.blockSize) {
1024              this.compress_(buf);
1025              inbuf = 0;
1026              break;
1027            }
1028          }
1029        } else {
1030          while (n < length) {
1031            buf[inbuf] = bytes[n];
1032            ++inbuf;
1033            ++n;
1034            if (inbuf === this.blockSize) {
1035              this.compress_(buf);
1036              inbuf = 0;
1037              break;
1038            }
1039          }
1040        }
1041      }
1042      this.inbuf_ = inbuf;
1043      this.total_ += length;
1044    }
1045    digest() {
1046      const digest = [];
1047      let totalBits = this.total_ * 8;
1048      if (this.inbuf_ < 56) {
1049        this.update(this.pad_, 56 - this.inbuf_);
1050      } else {
1051        this.update(this.pad_, this.blockSize - (this.inbuf_ - 56));
1052      }
1053      for (let i = this.blockSize - 1; i >= 56; i--) {
1054        this.buf_[i] = totalBits & 255;
1055        totalBits /= 256;
1056      }
1057      this.compress_(this.buf_);
1058      let n = 0;
1059      for (let i = 0; i < 5; i++) {
1060        for (let j = 24; j >= 0; j -= 8) {
1061          digest[n] = this.chain_[i] >> j & 255;
1062          ++n;
1063        }
1064      }
1065      return digest;
1066    }
1067  };
1068  function createSubscribe(executor, onNoObservers) {
1069    const proxy = new ObserverProxy(executor, onNoObservers);
1070    return proxy.subscribe.bind(proxy);
1071  }
1072  var ObserverProxy = class {
1073    constructor(executor, onNoObservers) {
1074      this.observers = [];
1075      this.unsubscribes = [];
1076      this.observerCount = 0;
1077      this.task = Promise.resolve();
1078      this.finalized = false;
1079      this.onNoObservers = onNoObservers;
1080      this.task.then(() => {
1081        executor(this);
1082      }).catch((e) => {
1083        this.error(e);
1084      });
1085    }
1086    next(value) {
1087      this.forEachObserver((observer) => {
1088        observer.next(value);
1089      });
1090    }
1091    error(error2) {
1092      this.forEachObserver((observer) => {
1093        observer.error(error2);
1094      });
1095      this.close(error2);
1096    }
1097    complete() {
1098      this.forEachObserver((observer) => {
1099        observer.complete();
1100      });
1101      this.close();
1102    }
1103    subscribe(nextOrObserver, error2, complete) {
1104      let observer;
1105      if (nextOrObserver === void 0 && error2 === void 0 && complete === void 0) {
1106        throw new Error("Missing Observer.");
1107      }
1108      if (implementsAnyMethods(nextOrObserver, [
1109        "next",
1110        "error",
1111        "complete"
1112      ])) {
1113        observer = nextOrObserver;
1114      } else {
1115        observer = {
1116          next: nextOrObserver,
1117          error: error2,
1118          complete
1119        };
1120      }
1121      if (observer.next === void 0) {
1122        observer.next = noop;
1123      }
1124      if (observer.error === void 0) {
1125        observer.error = noop;
1126      }
1127      if (observer.complete === void 0) {
1128        observer.complete = noop;
1129      }
1130      const unsub = this.unsubscribeOne.bind(this, this.observers.length);
1131      if (this.finalized) {
1132        this.task.then(() => {
1133          try {
1134            if (this.finalError) {
1135              observer.error(this.finalError);
1136            } else {
1137              observer.complete();
1138            }
1139          } catch (e) {
1140          }
1141          return;
1142        });
1143      }
1144      this.observers.push(observer);
1145      return unsub;
1146    }
1147    unsubscribeOne(i) {
1148      if (this.observers === void 0 || this.observers[i] === void 0) {
1149        return;
1150      }
1151      delete this.observers[i];
1152      this.observerCount -= 1;
1153      if (this.observerCount === 0 && this.onNoObservers !== void 0) {
1154        this.onNoObservers(this);
1155      }
1156    }
1157    forEachObserver(fn) {
1158      if (this.finalized) {
1159        return;
1160      }
1161      for (let i = 0; i < this.observers.length; i++) {
1162        this.sendOne(i, fn);
1163      }
1164    }
1165    sendOne(i, fn) {
1166      this.task.then(() => {
1167        if (this.observers !== void 0 && this.observers[i] !== void 0) {
1168          try {
1169            fn(this.observers[i]);
1170          } catch (e) {
1171            if (typeof console !== "undefined" && console.error) {
1172              console.error(e);
1173            }
1174          }
1175        }
1176      });
1177    }
1178    close(err) {
1179      if (this.finalized) {
1180        return;
1181      }
1182      this.finalized = true;
1183      if (err !== void 0) {
1184        this.finalError = err;
1185      }
1186      this.task.then(() => {
1187        this.observers = void 0;
1188        this.onNoObservers = void 0;
1189      });
1190    }
1191  };
1192  function implementsAnyMethods(obj, methods) {
1193    if (typeof obj !== "object" || obj === null) {
1194      return false;
1195    }
1196    for (const method of methods) {
1197      if (method in obj && typeof obj[method] === "function") {
1198        return true;
1199      }
1200    }
1201    return false;
1202  }
1203  function noop() {
1204  }
1205  function errorPrefix(fnName, argName) {
1206    return `${fnName} failed: ${argName} argument `;
1207  }
1208  var stringToByteArray = function(str) {
1209    const out = [];
1210    let p = 0;
1211    for (let i = 0; i < str.length; i++) {
1212      let c = str.charCodeAt(i);
1213      if (c >= 55296 && c <= 56319) {
1214        const high = c - 55296;
1215        i++;
1216        assert(i < str.length, "Surrogate pair missing trail surrogate.");
1217        const low = str.charCodeAt(i) - 56320;
1218        c = 65536 + (high << 10) + low;
1219      }
1220      if (c < 128) {
1221        out[p++] = c;
1222      } else if (c < 2048) {
1223        out[p++] = c >> 6 | 192;
1224        out[p++] = c & 63 | 128;
1225      } else if (c < 65536) {
1226        out[p++] = c >> 12 | 224;
1227        out[p++] = c >> 6 & 63 | 128;
1228        out[p++] = c & 63 | 128;
1229      } else {
1230        out[p++] = c >> 18 | 240;
1231        out[p++] = c >> 12 & 63 | 128;
1232        out[p++] = c >> 6 & 63 | 128;
1233        out[p++] = c & 63 | 128;
1234      }
1235    }
1236    return out;
1237  };
1238  var stringLength = function(str) {
1239    let p = 0;
1240    for (let i = 0; i < str.length; i++) {
1241      const c = str.charCodeAt(i);
1242      if (c < 128) {
1243        p++;
1244      } else if (c < 2048) {
1245        p += 2;
1246      } else if (c >= 55296 && c <= 56319) {
1247        p += 4;
1248        i++;
1249      } else {
1250        p += 3;
1251      }
1252    }
1253    return p;
1254  };
1255  var DEFAULT_INTERVAL_MILLIS = 1e3;
1256  var DEFAULT_BACKOFF_FACTOR = 2;
1257  var MAX_VALUE_MILLIS = 4 * 60 * 60 * 1e3;
1258  var RANDOM_FACTOR = 0.5;
1259  function calculateBackoffMillis(backoffCount, intervalMillis = DEFAULT_INTERVAL_MILLIS, backoffFactor = DEFAULT_BACKOFF_FACTOR) {
1260    const currBaseValue = intervalMillis * Math.pow(backoffFactor, backoffCount);
1261    const randomWait = Math.round(RANDOM_FACTOR * currBaseValue * (Math.random() - 0.5) * 2);
1262    return Math.min(MAX_VALUE_MILLIS, currBaseValue + randomWait);
1263  }
1264  function getModularInstance(service) {
1265    if (service && service._delegate) {
1266      return service._delegate;
1267    } else {
1268      return service;
1269    }
1270  }
1271
1272  

1272// node_modules/@firebase/component/dist/esm/index.esm2017.js
1273  var Component = class {
1274    constructor(name7, instanceFactory, type) {
1275      this.name = name7;
1276      this.instanceFactory = instanceFactory;
1277      this.type = type;
1278      this.multipleInstances = false;
1279      this.serviceProps = {};
1280      this.instantiationMode = "LAZY";
1281      this.onInstanceCreated = null;
1282    }
1283    setInstantiationMode(mode) {
1284      this.instantiationMode = mode;
1285      return this;
1286    }
1287    setMultipleInstances(multipleInstances) {
1288      this.multipleInstances = multipleInstances;
1289      return this;
1290    }
1291    setServiceProps(props) {
1292      this.serviceProps = props;
1293      return this;
1294    }
1295    setInstanceCreatedCallback(callback) {
1296      this.onInstanceCreated = callback;
1297      return this;
1298    }
1299  };
1300  var DEFAULT_ENTRY_NAME = "[DEFAULT]";
1301  var Provider = class {
1302    constructor(name7, container) {
1303      this.name = name7;
1304      this.container = container;
1305      this.component = null;
1306      this.instances = /* @__PURE__ */ new Map();
1307      this.instancesDeferred = /* @__PURE__ */ new Map();
1308      this.instancesOptions = /* @__PURE__ */ new Map();
1309      this.onInitCallbacks = /* @__PURE__ */ new Map();
1310    }
1311    get(identifier) {
1312      const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);
1313      if (!this.instancesDeferred.has(normalizedIdentifier)) {
1314        const deferred = new Deferred();
1315        this.instancesDeferred.set(normalizedIdentifier, deferred);
1316        if (this.isInitialized(normalizedIdentifier) || this.shouldAutoInitialize()) {
1317          try {
1318            const instance = this.getOrInitializeService({
1319              instanceIdentifier: normalizedIdentifier
1320            });
1321            if (instance) {
1322              deferred.resolve(instance);
1323            }
1324          } catch (e) {
1325          }
1326        }
1327      }
1328      return this.instancesDeferred.get(normalizedIdentifier).promise;
1329    }
1330    getImmediate(options) {
1331      var _a;
1332      const normalizedIdentifier = this.normalizeInstanceIdentifier(options === null || options === void 0 ? void 0 : options.identifier);
1333      const optional = (_a = options === null || options === void 0 ? void 0 : options.optional) !== null && _a !== void 0 ? _a : false;
1334      if (this.isInitialized(normalizedIdentifier) || this.shouldAutoInitialize()) {
1335        try {
1336          return this.getOrInitializeService({
1337            instanceIdentifier: normalizedIdentifier
1338          });
1339        } catch (e) {
1340          if (optional) {
1341            return null;
1342          } else {
1343            throw e;
1344          }
1345        }
1346      } else {
1347        if (optional) {
1348          return null;
1349        } else {
1350          throw Error(`Service ${this.name} is not available`);
1351        }
1352      }
1353    }
1354    getComponent() {
1355      return this.component;
1356    }
1357    setComponent(component) {
1358      if (component.name !== this.name) {
1359        throw Error(`Mismatching Component ${component.name} for Provider ${this.name}.`);
1360      }
1361      if (this.component) {
1362        throw Error(`Component for ${this.name} has already been provided`);
1363      }
1364      this.component = component;
1365      if (!this.shouldAutoInitialize()) {
1366        return;
1367      }
1368      if (isComponentEager(component)) {
1369        try {
1370          this.getOrInitializeService({ instanceIdentifier: DEFAULT_ENTRY_NAME });
1371        } catch (e) {
1372        }
1373      }
1374      for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) {
1375        const normalizedIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier);
1376        try {
1377          const instance = this.getOrInitializeService({
1378            instanceIdentifier: normalizedIdentifier
1379          });
1380          instanceDeferred.resolve(instance);
1381        } catch (e) {
1382        }
1383      }
1384    }
1385    clearInstance(identifier = DEFAULT_ENTRY_NAME) {
1386      this.instancesDeferred.delete(identifier);
1387      this.instancesOptions.delete(identifier);
1388      this.instances.delete(identifier);
1389    }
1390    async delete() {
1391      const services = Array.from(this.instances.values());
1392      await Promise.all([
1393        ...services.filter((service) => "INTERNAL" in service).map((service) => service.INTERNAL.delete()),
1394        ...services.filter((service) => "_delete" in service).map((service) => service._delete())
1395      ]);
1396    }
1397    isComponentSet() {
1398      return this.component != null;
1399    }
1400    isInitialized(identifier = DEFAULT_ENTRY_NAME) {
1401      return this.instances.has(identifier);
1402    }
1403    getOptions(identifier = DEFAULT_ENTRY_NAME) {
1404      return this.instancesOptions.get(identifier) || {};
1405    }
1406    initialize(opts = {}) {
1407      const { options = {} } = opts;
1408      const normalizedIdentifier = this.normalizeInstanceIdentifier(opts.instanceIdentifier);
1409      if (this.isInitialized(normalizedIdentifier)) {
1410        throw Error(`${this.name}(${normalizedIdentifier}) has already been initialized`);
1411      }
1412      if (!this.isComponentSet()) {
1413        throw Error(`Component ${this.name} has not been registered yet`);
1414      }
1415      const instance = this.getOrInitializeService({
1416        instanceIdentifier: normalizedIdentifier,
1417        options
1418      });
1419      for (const [instanceIdentifier, instanceDeferred] of this.instancesDeferred.entries()) {
1420        const normalizedDeferredIdentifier = this.normalizeInstanceIdentifier(instanceIdentifier);
1421        if (normalizedIdentifier === normalizedDeferredIdentifier) {
1422          instanceDeferred.resolve(instance);
1423        }
1424      }
1425      return instance;
1426    }
1427    onInit(callback, identifier) {
1428      var _a;
1429      const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);
1430      const existingCallbacks = (_a = this.onInitCallbacks.get(normalizedIdentifier)) !== null && _a !== void 0 ? _a : /* @__PURE__ */ new Set();
1431      existingCallbacks.add(callback);
1432      this.onInitCallbacks.set(normalizedIdentifier, existingCallbacks);
1433      const existingInstance = this.instances.get(normalizedIdentifier);
1434      if (existingInstance) {
1435        callback(existingInstance, normalizedIdentifier);
1436      }
1437      return () => {
1438        existingCallbacks.delete(callback);
1439      };
1440    }
1441    invokeOnInitCallbacks(instance, identifier) {
1442      const callbacks = this.onInitCallbacks.get(identifier);
1443      if (!callbacks) {
1444        return;
1445      }
1446      for (const callback of callbacks) {
1447        try {
1448          callback(instance, identifier);
1449        } catch (_a) {
1450        }
1451      }
1452    }
1453    getOrInitializeService({ instanceIdentifier, options = {} }) {
1454      let instance = this.instances.get(instanceIdentifier);
1455      if (!instance && this.component) {
1456        instance = this.component.instanceFactory(this.container, {
1457          instanceIdentifier: normalizeIdentifierForFactory(instanceIdentifier),
1458          options
1459        });
1460        this.instances.set(instanceIdentifier, instance);
1461        this.instancesOptions.set(instanceIdentifier, options);
1462        this.invokeOnInitCallbacks(instance, instanceIdentifier);
1463        if (this.component.onInstanceCreated) {
1464          try {
1465            this.component.onInstanceCreated(this.container, instanceIdentifier, instance);
1466          } catch (_a) {
1467          }
1468        }
1469      }
1470      return instance || null;
1471    }
1472    normalizeInstanceIdentifier(identifier = DEFAULT_ENTRY_NAME) {
1473      if (this.component) {
1474        return this.component.multipleInstances ? identifier : DEFAULT_ENTRY_NAME;
1475      } else {
1476        return identifier;
1477      }
1478    }
1479    shouldAutoInitialize() {
1480      return !!this.component && this.component.instantiationMode !== "EXPLICIT";
1481    }
1482  };
1483  function normalizeIdentifierForFactory(identifier) {
1484    return identifier === DEFAULT_ENTRY_NAME ? void 0 : identifier;
1485  }
1486  function isComponentEager(component) {
1487    return component.instantiationMode === "EAGER";
1488  }
1489  var ComponentContainer = class {
1490    constructor(name7) {
1491      this.name = name7;
1492      this.providers = /* @__PURE__ */ new Map();
1493    }
1494    addComponent(component) {
1495      const provider = this.getProvider(component.name);
1496      if (provider.isComponentSet()) {
1497        throw new Error(`Component ${component.name} has already been registered with ${this.name}`);
1498      }
1499      provider.setComponent(component);
1500    }
1501    addOrOverwriteComponent(component) {
1502      const provider = this.getProvider(component.name);
1503      if (provider.isComponentSet()) {
1504        this.providers.delete(component.name);
1505      }
1506      this.addComponent(component);
1507    }
1508    getProvider(name7) {
1509      if (this.providers.has(name7)) {
1510        return this.providers.get(name7);
1511      }
1512      const provider = new Provider(name7, this);
1513      this.providers.set(name7, provider);
1514      return provider;
1515    }
1516    getProviders() {
1517      return Array.from(this.providers.values());
1518    }
1519  };
1520
1521  

1521// node_modules/@firebase/logger/dist/esm/index.esm2017.js
1522  var instances = [];
1523  var LogLevel;
1524  (function(LogLevel2) {
1525    LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
1526    LogLevel2[LogLevel2["VERBOSE"] = 1] = "VERBOSE";
1527    LogLevel2[LogLevel2["INFO"] = 2] = "INFO";
1528    LogLevel2[LogLevel2["WARN"] = 3] = "WARN";
1529    LogLevel2[LogLevel2["ERROR"] = 4] = "ERROR";
1530    LogLevel2[LogLevel2["SILENT"] = 5] = "SILENT";
1531  })(LogLevel || (LogLevel = {}));
1532  var levelStringToEnum = {
1533    "debug": LogLevel.DEBUG,
1534    "verbose": LogLevel.VERBOSE,
1535    "info": LogLevel.INFO,
1536    "warn": LogLevel.WARN,
1537    "error": LogLevel.ERROR,
1538    "silent": LogLevel.SILENT
1539  };
1540  var defaultLogLevel = LogLevel.INFO;
1541  var ConsoleMethod = {
1542    [LogLevel.DEBUG]: "log",
1543    [LogLevel.VERBOSE]: "log",
1544    [LogLevel.INFO]: "info",
1545    [LogLevel.WARN]: "warn",
1546    [LogLevel.ERROR]: "error"
1547  };
1548  var defaultLogHandler = (instance, logType, ...args) => {
1549    if (logType < instance.logLevel) {
1550      return;
1551    }
1552    const now = new Date().toISOString();
1553    const method = ConsoleMethod[logType];
1554    if (method) {
1555      console[method](`[${now}]  ${instance.name}:`, ...args);
1556    } else {
1557      throw new Error(`Attempted to log a message with an invalid logType (value: ${logType})`);
1558    }
1559  };
1560  var Logger = class {
1561    constructor(name7) {
1562      this.name = name7;
1563      this._logLevel = defaultLogLevel;
1564      this._logHandler = defaultLogHandler;
1565      this._userLogHandler = null;
1566      instances.push(this);
1567    }
1568    get logLevel() {
1569      return this._logLevel;
1570    }
1571    set logLevel(val) {
1572      if (!(val in LogLevel)) {
1573        throw new TypeError(`Invalid value "${val}" assigned to \`logLevel\``);
1574      }
1575      this._logLevel = val;
1576    }
1577    setLogLevel(val) {
1578      this._logLevel = typeof val === "string" ? levelStringToEnum[val] : val;
1579    }
1580    get logHandler() {
1581      return this._logHandler;
1582    }
1583    set logHandler(val) {
1584      if (typeof val !== "function") {
1585        throw new TypeError("Value assigned to `logHandler` must be a function");
1586      }
1587      this._logHandler = val;
1588    }
1589    get userLogHandler() {
1590      return this._userLogHandler;
1591    }
1592    set userLogHandler(val) {
1593      this._userLogHandler = val;
1594    }
1595    debug(...args) {
1596      this._userLogHandler && this._userLogHandler(this, LogLevel.DEBUG, ...args);
1597      this._logHandler(this, LogLevel.DEBUG, ...args);
1598    }
1599    log(...args) {
1600      this._userLogHandler && this._userLogHandler(this, LogLevel.VERBOSE, ...args);
1601      this._logHandler(this, LogLevel.VERBOSE, ...args);
1602    }
1603    info(...args) {
1604      this._userLogHandler && this._userLogHandler(this, LogLevel.INFO, ...args);
1605      this._logHandler(this, LogLevel.INFO, ...args);
1606    }
1607    warn(...args) {
1608      this._userLogHandler && this._userLogHandler(this, LogLevel.WARN, ...args);
1609      this._logHandler(this, LogLevel.WARN, ...args);
1610    }
1611    error(...args) {
1612      this._userLogHandler && this._userLogHandler(this, LogLevel.ERROR, ...args);
1613      this._logHandler(this, LogLevel.ERROR, ...args);
1614    }
1615  };
1616
1617  

1617// node_modules/idb/build/wrap-idb-value.js
1618  var instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
1619  var idbProxyableTypes;
1620  var cursorAdvanceMethods;
1621  function getIdbProxyableTypes() {
1622    return idbProxyableTypes || (idbProxyableTypes = [
1623      IDBDatabase,
1624      IDBObjectStore,
1625      IDBIndex,
1626      IDBCursor,
1627      IDBTransaction
1628    ]);
1629  }
1630  function getCursorAdvanceMethods() {
1631    return cursorAdvanceMethods || (cursorAdvanceMethods = [
1632      IDBCursor.prototype.advance,
1633      IDBCursor.prototype.continue,
1634      IDBCursor.prototype.continuePrimaryKey
1635    ]);
1636  }
1637  var cursorRequestMap = /* @__PURE__ */ new WeakMap();
1638  var transactionDoneMap = /* @__PURE__ */ new WeakMap();
1639  var transactionStoreNamesMap = /* @__PURE__ */ new WeakMap();
1640  var transformCache = /* @__PURE__ */ new WeakMap();
1641  var reverseTransformCache = /* @__PURE__ */ new WeakMap();
1642  function promisifyRequest(request) {
1643    const promise = new Promise((resolve, reject) => {
1644      const unlisten = () => {
1645        request.removeEventListener("success", success);
1646        request.removeEventListener("error", error2);
1647      };
1648      const success = () => {
1649        resolve(wrap(request.result));
1650        unlisten();
1651      };
1652      const error2 = () => {
1653        reject(request.error);
1654        unlisten();
1655      };
1656      request.addEventListener("success", success);
1657      request.addEventListener("error", error2);
1658    });
1659    promise.then((value) => {
1660      if (value instanceof IDBCursor) {
1661        cursorRequestMap.set(value, request);
1662      }
1663    }).catch(() => {
1664    });
1665    reverseTransformCache.set(promise, request);
1666    return promise;
1667  }
1668  function cacheDonePromiseForTransaction(tx) {
1669    if (transactionDoneMap.has(tx))
1670      return;
1671    const done = new Promise((resolve, reject) => {
1672      const unlisten = () => {
1673        tx.removeEventListener("complete", complete);
1674        tx.removeEventListener("error", error2);
1675        tx.removeEventListener("abort", error2);
1676      };
1677      const complete = () => {
1678        resolve();
1679        unlisten();
1680      };
1681      const error2 = () => {
1682        reject(tx.error || new DOMException("AbortError", "AbortError"));
1683        unlisten();
1684      };
1685      tx.addEventListener("complete", complete);
1686      tx.addEventListener("error", error2);
1687      tx.addEventListener("abort", error2);
1688    });
1689    transactionDoneMap.set(tx, done);
1690  }
1691  var idbProxyTraps = {
1692    get(target, prop, receiver) {
1693      if (target instanceof IDBTransaction) {
1694        if (prop === "done")
1695          return transactionDoneMap.get(target);
1696        if (prop === "objectStoreNames") {
1697          return target.objectStoreNames || transactionStoreNamesMap.get(target);
1698        }
1699        if (prop === "store") {
1700          return receiver.objectStoreNames[1] ? void 0 : receiver.objectStore(receiver.objectStoreNames[0]);
1701        }
1702      }
1703      return wrap(target[prop]);
1704    },
1705    set(target, prop, value) {
1706      target[prop] = value;
1707      return true;
1708    },
1709    has(target, prop) {
1710      if (target instanceof IDBTransaction && (prop === "done" || prop === "store")) {
1711        return true;
1712      }
1713      return prop in target;
1714    }
1715  };
1716  function replaceTraps(callback) {
1717    idbProxyTraps = callback(idbProxyTraps);
1718  }
1719  function wrapFunction(func) {
1720    if (func === IDBDatabase.prototype.transaction && !("objectStoreNames" in IDBTransaction.prototype)) {
1721      return function(storeNames, ...args) {
1722        const tx = func.call(unwrap(this), storeNames, ...args);
1723        transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);
1724        return wrap(tx);
1725      };
1726    }
1727    if (getCursorAdvanceMethods().includes(func)) {
1728      return function(...args) {
1729        func.apply(unwrap(this), args);
1730        return wrap(cursorRequestMap.get(this));
1731      };
1732    }
1733    return function(...args) {
1734      return wrap(func.apply(unwrap(this), args));
1735    };
1736  }
1737  function transformCachableValue(value) {
1738    if (typeof value === "function")
1739      return wrapFunction(value);
1740    if (value instanceof IDBTransaction)
1741      cacheDonePromiseForTransaction(value);
1742    if (instanceOfAny(value, getIdbProxyableTypes()))
1743      return new Proxy(value, idbProxyTraps);
1744    return value;
1745  }
1746  function wrap(value) {
1747    if (value instanceof IDBRequest)
1748      return promisifyRequest(value);
1749    if (transformCache.has(value))
1750      return transformCache.get(value);
1751    const newValue = transformCachableValue(value);
1752    if (newValue !== value) {
1753      transformCache.set(value, newValue);
1754      reverseTransformCache.set(newValue, value);
1755    }
1756    return newValue;
1757  }
1758  var unwrap = (value) => reverseTransformCache.get(value);
1759
1760  

1760// node_modules/idb/build/index.js
1761  function openDB(name7, version7, { blocked, upgrade, blocking, terminated } = {}) {
1762    const request = indexedDB.open(name7, version7);
1763    const openPromise = wrap(request);
1764    if (upgrade) {
1765      request.addEventListener("upgradeneeded", (event) => {
1766        upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction));
1767      });
1768    }
1769    if (blocked)
1770      request.addEventListener("blocked", () => blocked());
1771    openPromise.then((db2) => {
1772      if (terminated)
1773        db2.addEventListener("close", () => terminated());
1774      if (blocking)
1775        db2.addEventListener("versionchange", () => blocking());
1776    }).catch(() => {
1777    });
1778    return openPromise;
1779  }
1780  var readMethods = ["get", "getKey", "getAll", "getAllKeys", "count"];
1781  var writeMethods = ["put", "add", "delete", "clear"];
1782  var cachedMethods = /* @__PURE__ */ new Map();
1783  function getMethod(target, prop) {
1784    if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === "string")) {
1785      return;
1786    }
1787    if (cachedMethods.get(prop))
1788      return cachedMethods.get(prop);
1789    const targetFuncName = prop.replace(/FromIndex$/, "");
1790    const useIndex = prop !== targetFuncName;
1791    const isWrite = writeMethods.includes(targetFuncName);
1792    if (!(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) {
1793      return;
1794    }
1795    const method = async function(storeName, ...args) {
1796      const tx = this.transaction(storeName, isWrite ? "readwrite" : "readonly");
1797      let target2 = tx.store;
1798      if (useIndex)
1799        target2 = target2.index(args.shift());
1800      return (await Promise.all([
1801        target2[targetFuncName](...args),
1802        isWrite && tx.done
1803      ]))[0];
1804    };
1805    cachedMethods.set(prop, method);
1806    return method;
1807  }
1808  replaceTraps((oldTraps) => ({
1809    ...oldTraps,
1810    get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
1811    has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
1812  }));
1813
1814  

1814// node_modules/@firebase/app/dist/esm/index.esm2017.js
1815  var PlatformLoggerServiceImpl = class {
1816    constructor(container) {
1817      this.container = container;
1818    }
1819    getPlatformInfoString() {
1820      const providers = this.container.getProviders();
1821      return providers.map((provider) => {
1822        if (isVersionServiceProvider(provider)) {
1823          const service = provider.getImmediate();
1824          return `${service.library}/${service.version}`;
1825        } else {
1826          return null;
1827        }
1828      }).filter((logString) => logString).join(" ");
1829    }
1830  };
1831  function isVersionServiceProvider(provider) {
1832    const component = provider.getComponent();
1833    return (component === null || component === void 0 ? void 0 : component.type) === "VERSION";
1834  }
1835  var name$o = "@firebase/app";
1836  var version$1 = "0.7.32";
1837  var logger = new Logger("@firebase/app");
1838  var name$n = "@firebase/app-compat";
1839  var name$m = "@firebase/analytics-compat";
1840  var name$l = "@firebase/analytics";
1841  var name$k = "@firebase/app-check-compat";
1842  var name$j = "@firebase/app-check";
1843  var name$i = "@firebase/auth";
1844  var name$h = "@firebase/auth-compat";
1845  var name$g = "@firebase/database";
1846  var name$f = "@firebase/database-compat";
1847  var name$e = "@firebase/functions";
1848  var name$d = "@firebase/functions-compat";
1849  var name$c = "@firebase/installations";
1850  var name$b = "@firebase/installations-compat";
1851  var name$a = "@firebase/messaging";
1852  var name$9 = "@firebase/messaging-compat";
1853  var name$8 = "@firebase/performance";
1854  var name$7 = "@firebase/performance-compat";
1855  var name$6 = "@firebase/remote-config";
1856  var name$5 = "@firebase/remote-config-compat";
1857  var name$4 = "@firebase/storage";
1858  var name$3 = "@firebase/storage-compat";
1859  var name$2 = "@firebase/firestore";
1860  var name$1 = "@firebase/firestore-compat";
1861  var name = "firebase";
1862  var version = "9.9.4";
1863  var DEFAULT_ENTRY_NAME2 = "[DEFAULT]";
1864  var PLATFORM_LOG_STRING = {
1865    [name$o]: "fire-core",
1866    [name$n]: "fire-core-compat",
1867    [name$l]: "fire-analytics",
1868    [name$m]: "fire-analytics-compat",
1869    [name$j]: "fire-app-check",
1870    [name$k]: "fire-app-check-compat",
1871    [name$i]: "fire-auth",
1872    [name$h]: "fire-auth-compat",
1873    [name$g]: "fire-rtdb",
1874    [name$f]: "fire-rtdb-compat",
1875    [name$e]: "fire-fn",
1876    [name$d]: "fire-fn-compat",
1877    [name$c]: "fire-iid",
1878    [name$b]: "fire-iid-compat",
1879    [name$a]: "fire-fcm",
1880    [name$9]: "fire-fcm-compat",
1881    [name$8]: "fire-perf",
1882    [name$7]: "fire-perf-compat",
1883    [name$6]: "fire-rc",
1884    [name$5]: "fire-rc-compat",
1885    [name$4]: "fire-gcs",
1886    [name$3]: "fire-gcs-compat",
1887    [name$2]: "fire-fst",
1888    [name$1]: "fire-fst-compat",
1889    "fire-js": "fire-js",
1890    [name]: "fire-js-all"
1891  };
1892  var _apps = /* @__PURE__ */ new Map();
1893  var _components = /* @__PURE__ */ new Map();
1894  function _addComponent(app2, component) {
1895    try {
1896      app2.container.addComponent(component);
1897    } catch (e) {
1898      logger.debug(`Component ${component.name} failed to register with FirebaseApp ${app2.name}`, e);
1899    }
1900  }
1901  function _registerComponent(component) {
1902    const componentName = component.name;
1903    if (_components.has(componentName)) {
1904      logger.debug(`There were multiple attempts to register component ${componentName}.`);
1905      return false;
1906    }
1907    _components.set(componentName, component);
1908    for (const app2 of _apps.values()) {
1909      _addComponent(app2, component);
1910    }
1911    return true;
1912  }
1913  function _getProvider(app2, name7) {
1914    const heartbeatController = app2.container.getProvider("heartbeat").getImmediate({ optional: true });
1915    if (heartbeatController) {
1916      void heartbeatController.triggerHeartbeat();
1917    }
1918    return app2.container.getProvider(name7);
1919  }
1920  var ERRORS = {
1921    ["no-app"]: "No Firebase App '{$appName}' has been created - call Firebase App.initializeApp()",
1922    ["bad-app-name"]: "Illegal App name: '{$appName}",
1923    ["duplicate-app"]: "Firebase App named '{$appName}' already exists with different options or config",
1924    ["app-deleted"]: "Firebase App named '{$appName}' already deleted",
1925    ["invalid-app-argument"]: "firebase.{$appName}() takes either no argument or a Firebase App instance.",
1926    ["invalid-log-argument"]: "First argument to `onLog` must be null or a function.",
1927    ["idb-open"]: "Error thrown when opening IndexedDB. Original error: {$originalErrorMessage}.",
1928    ["idb-get"]: "Error thrown when reading from IndexedDB. Original error: {$originalErrorMessage}.",
1929    ["idb-set"]: "Error thrown when writing to IndexedDB. Original error: {$originalErrorMessage}.",
1930    ["idb-delete"]: "Error thrown when deleting from IndexedDB. Original error: {$originalErrorMessage}."
1931  };
1932  var ERROR_FACTORY = new ErrorFactory("app", "Firebase", ERRORS);
1933  var FirebaseAppImpl = class {
1934    constructor(options, config, container) {
1935      this._isDeleted = false;
1936      this._options = Object.assign({}, options);
1937      this._config = Object.assign({}, config);
1938      this._name = config.name;
1939      this._automaticDataCollectionEnabled = config.automaticDataCollectionEnabled;
1940      this._container = container;
1941      this.container.addComponent(new Component("app", () => this, "PUBLIC"));
1942    }
1943    get automaticDataCollectionEnabled() {
1944      this.checkDestroyed();
1945      return this._automaticDataCollectionEnabled;
1946    }
1947    set automaticDataCollectionEnabled(val) {
1948      this.checkDestroyed();
1949      this._automaticDataCollectionEnabled = val;
1950    }
1951    get name() {
1952      this.checkDestroyed();
1953      return this._name;
1954    }
1955    get options() {
1956      this.checkDestroyed();
1957      return this._options;
1958    }
1959    get config() {
1960      this.checkDestroyed();
1961      return this._config;
1962    }
1963    get container() {
1964      return this._container;
1965    }
1966    get isDeleted() {
1967      return this._isDeleted;
1968    }
1969    set isDeleted(val) {
1970      this._isDeleted = val;
1971    }
1972    checkDestroyed() {
1973      if (this.isDeleted) {
1974        throw ERROR_FACTORY.create("app-deleted", { appName: this._name });
1975      }
1976    }
1977  };
1978  var SDK_VERSION = version;
1979  function initializeApp(options, rawConfig = {}) {
1980    if (typeof rawConfig !== "object") {
1981      const name8 = rawConfig;
1982      rawConfig = { name: name8 };
1983    }
1984    const config = Object.assign({ name: DEFAULT_ENTRY_NAME2, automaticDataCollectionEnabled: false }, rawConfig);
1985    const name7 = config.name;
1986    if (typeof name7 !== "string" || !name7) {
1987      throw ERROR_FACTORY.create("bad-app-name", {
1988        appName: String(name7)
1989      });
1990    }
1991    const existingApp = _apps.get(name7);
1992    if (existingApp) {
1993      if (deepEqual(options, existingApp.options) && deepEqual(config, existingApp.config)) {
1994        return existingApp;
1995      } else {
1996        throw ERROR_FACTORY.create("duplicate-app", { appName: name7 });
1997      }
1998    }
1999    const container = new ComponentContainer(name7);
2000    for (const component of _components.values()) {
2001      container.addComponent(component);
2002    }
2003    const newApp = new FirebaseAppImpl(options, config, container);
2004    _apps.set(name7, newApp);
2005    return newApp;
2006  }
2007  function getApp(name7 = DEFAULT_ENTRY_NAME2) {
2008    const app2 = _apps.get(name7);
2009    if (!app2) {
2010      throw ERROR_FACTORY.create("no-app", { appName: name7 });
2011    }
2012    return app2;
2013  }
2014  function registerVersion(libraryKeyOrName, version7, variant) {
2015    var _a;
2016    let library = (_a = PLATFORM_LOG_STRING[libraryKeyOrName]) !== null && _a !== void 0 ? _a : libraryKeyOrName;
2017    if (variant) {
2018      library += `-${variant}`;
2019    }
2020    const libraryMismatch = library.match(/\s|\//);
2021    const versionMismatch = version7.match(/\s|\//);
2022    if (libraryMismatch || versionMismatch) {
2023      const warning = [
2024        `Unable to register library "${library}" with version "${version7}":`
2025      ];
2026      if (libraryMismatch) {
2027        warning.push(`library name "${library}" contains illegal characters (whitespace or "/")`);
2028      }
2029      if (libraryMismatch && versionMismatch) {
2030        warning.push("and");
2031      }
2032      if (versionMismatch) {
2033        warning.push(`version name "${version7}" contains illegal characters (whitespace or "/")`);
2034      }
2035      logger.warn(warning.join(" "));
2036      return;
2037    }
2038    _registerComponent(new Component(`${library}-version`, () => ({ library, version: version7 }), "VERSION"));
2039  }
2040  var DB_NAME = "firebase-heartbeat-database";
2041  var DB_VERSION = 1;
2042  var STORE_NAME = "firebase-heartbeat-store";
2043  var dbPromise = null;
2044  function getDbPromise() {
2045    if (!dbPromise) {
2046      dbPromise = openDB(DB_NAME, DB_VERSION, {
2047        upgrade: (db2, oldVersion) => {
2048          switch (oldVersion) {
2049            case 0:
2050              db2.createObjectStore(STORE_NAME);
2051          }
2052        }
2053      }).catch((e) => {
2054        throw ERROR_FACTORY.create("idb-open", {
2055          originalErrorMessage: e.message
2056        });
2057      });
2058    }
2059    return dbPromise;
2060  }
2061  async function readHeartbeatsFromIndexedDB(app2) {
2062    var _a;
2063    try {
2064      const db2 = await getDbPromise();
2065      return db2.transaction(STORE_NAME).objectStore(STORE_NAME).get(computeKey(app2));
2066    } catch (e) {
2067      if (e instanceof FirebaseError) {
2068        logger.warn(e.message);
2069      } else {
2070        const idbGetError = ERROR_FACTORY.create("idb-get", {
2071          originalErrorMessage: (_a = e) === null || _a === void 0 ? void 0 : _a.message
2072        });
2073        logger.warn(idbGetError.message);
2074      }
2075    }
2076  }
2077  async function writeHeartbeatsToIndexedDB(app2, heartbeatObject) {
2078    var _a;
2079    try {
2080      const db2 = await getDbPromise();
2081      const tx = db2.transaction(STORE_NAME, "readwrite");
2082      const objectStore = tx.objectStore(STORE_NAME);
2083      await objectStore.put(heartbeatObject, computeKey(app2));
2084      return tx.done;
2085    } catch (e) {
2086      if (e instanceof FirebaseError) {
2087        logger.warn(e.message);
2088      } else {
2089        const idbGetError = ERROR_FACTORY.create("idb-set", {
2090          originalErrorMessage: (_a = e) === null || _a === void 0 ? void 0 : _a.message
2091        });
2092        logger.warn(idbGetError.message);
2093      }
2094    }
2095  }
2096  function computeKey(app2) {
2097    return `${app2.name}!${app2.options.appId}`;
2098  }
2099  var MAX_HEADER_BYTES = 1024;
2100  var STORED_HEARTBEAT_RETENTION_MAX_MILLIS = 30 * 24 * 60 * 60 * 1e3;
2101  var HeartbeatServiceImpl = class {
2102    constructor(container) {
2103      this.container = container;
2104      this._heartbeatsCache = null;
2105      const app2 = this.container.getProvider("app").getImmediate();
2106      this._storage = new HeartbeatStorageImpl(app2);
2107      this._heartbeatsCachePromise = this._storage.read().then((result) => {
2108        this._heartbeatsCache = result;
2109        return result;
2110      });
2111    }
2112    async triggerHeartbeat() {
2113      const platformLogger = this.container.getProvider("platform-logger").getImmediate();
2114      const agent = platformLogger.getPlatformInfoString();
2115      const date = getUTCDateString();
2116      if (this._heartbeatsCache === null) {
2117        this._heartbeatsCache = await this._heartbeatsCachePromise;
2118      }
2119      if (this._heartbeatsCache.lastSentHeartbeatDate === date || this._heartbeatsCache.heartbeats.some((singleDateHeartbeat) => singleDateHeartbeat.date === date)) {
2120        return;
2121      } else {
2122        this._heartbeatsCache.heartbeats.push({ date, agent });
2123      }
2124      this._heartbeatsCache.heartbeats = this._heartbeatsCache.heartbeats.filter((singleDateHeartbeat) => {
2125        const hbTimestamp = new Date(singleDateHeartbeat.date).valueOf();
2126        const now = Date.now();
2127        return now - hbTimestamp <= STORED_HEARTBEAT_RETENTION_MAX_MILLIS;
2128      });
2129      return this._storage.overwrite(this._heartbeatsCache);
2130    }
2131    async getHeartbeatsHeader() {
2132      if (this._heartbeatsCache === null) {
2133        await this._heartbeatsCachePromise;
2134      }
2135      if (this._heartbeatsCache === null || this._heartbeatsCache.heartbeats.length === 0) {
2136        return "";
2137      }
2138      const date = getUTCDateString();
2139      const { heartbeatsToSend, unsentEntries } = extractHeartbeatsForHeader(this._heartbeatsCache.heartbeats);
2140      const headerString = base64urlEncodeWithoutPadding(JSON.stringify({ version: 2, heartbeats: heartbeatsToSend }));
2141      this._heartbeatsCache.lastSentHeartbeatDate = date;
2142      if (unsentEntries.length > 0) {
2143        this._heartbeatsCache.heartbeats = unsentEntries;
2144        await this._storage.overwrite(this._heartbeatsCache);
2145      } else {
2146        this._heartbeatsCache.heartbeats = [];
2147        void this._storage.overwrite(this._heartbeatsCache);
2148      }
2149      return headerString;
2150    }
2151  };
2152  function getUTCDateString() {
2153    const today = new Date();
2154    return today.toISOString().substring(0, 10);
2155  }
2156  function extractHeartbeatsForHeader(heartbeatsCache, maxSize = MAX_HEADER_BYTES) {
2157    const heartbeatsToSend = [];
2158    let unsentEntries = heartbeatsCache.slice();
2159    for (const singleDateHeartbeat of heartbeatsCache) {
2160      const heartbeatEntry = heartbeatsToSend.find((hb) => hb.agent === singleDateHeartbeat.agent);
2161      if (!heartbeatEntry) {
2162        heartbeatsToSend.push({
2163          agent: singleDateHeartbeat.agent,
2164          dates: [singleDateHeartbeat.date]
2165        });
2166        if (countBytes(heartbeatsToSend) > maxSize) {
2167          heartbeatsToSend.pop();
2168          break;
2169        }
2170      } else {
2171        heartbeatEntry.dates.push(singleDateHeartbeat.date);
2172        if (countBytes(heartbeatsToSend) > maxSize) {
2173          heartbeatEntry.dates.pop();
2174          break;
2175        }
2176      }
2177      unsentEntries = unsentEntries.slice(1);
2178    }
2179    return {
2180      heartbeatsToSend,
2181      unsentEntries
2182    };
2183  }
2184  var HeartbeatStorageImpl = class {
2185    constructor(app2) {
2186      this.app = app2;
2187      this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();
2188    }
2189    async runIndexedDBEnvironmentCheck() {
2190      if (!isIndexedDBAvailable()) {
2191        return false;
2192      } else {
2193        return validateIndexedDBOpenable().then(() => true).catch(() => false);
2194      }
2195    }
2196    async read() {
2197      const canUseIndexedDB = await this._canUseIndexedDBPromise;
2198      if (!canUseIndexedDB) {
2199        return { heartbeats: [] };
2200      } else {
2201        const idbHeartbeatObject = await readHeartbeatsFromIndexedDB(this.app);
2202        return idbHeartbeatObject || { heartbeats: [] };
2203      }
2204    }
2205    async overwrite(heartbeatsObject) {
2206      var _a;
2207      const canUseIndexedDB = await this._canUseIndexedDBPromise;
2208      if (!canUseIndexedDB) {
2209        return;
2210      } else {
2211        const existingHeartbeatsObject = await this.read();
2212        return writeHeartbeatsToIndexedDB(this.app, {
2213          lastSentHeartbeatDate: (_a = heartbeatsObject.lastSentHeartbeatDate) !== null && _a !== void 0 ? _a : existingHeartbeatsObject.lastSentHeartbeatDate,
2214          heartbeats: heartbeatsObject.heartbeats
2215        });
2216      }
2217    }
2218    async add(heartbeatsObject) {
2219      var _a;
2220      const canUseIndexedDB = await this._canUseIndexedDBPromise;
2221      if (!canUseIndexedDB) {
2222        return;
2223      } else {
2224        const existingHeartbeatsObject = await this.read();
2225        return writeHeartbeatsToIndexedDB(this.app, {
2226          lastSentHeartbeatDate: (_a = heartbeatsObject.lastSentHeartbeatDate) !== null && _a !== void 0 ? _a : existingHeartbeatsObject.lastSentHeartbeatDate,
2227          heartbeats: [
2228            ...existingHeartbeatsObject.heartbeats,
2229            ...heartbeatsObject.heartbeats
2230          ]
2231        });
2232      }
2233    }
2234  };
2235  function countBytes(heartbeatsCache) {
2236    return base64urlEncodeWithoutPadding(JSON.stringify({ version: 2, heartbeats: heartbeatsCache })).length;
2237  }
2238  function registerCoreComponents(variant) {
2239    _registerComponent(new Component("platform-logger", (container) => new PlatformLoggerServiceImpl(container), "PRIVATE"));
2240    _registerComponent(new Component("heartbeat", (container) => new HeartbeatServiceImpl(container), "PRIVATE"));
2241    registerVersion(name$o, version$1, variant);
2242    registerVersion(name$o, version$1, "esm2017");
2243    registerVersion("fire-js", "");
2244  }
2245  registerCoreComponents("");
2246
2247  

2247// node_modules/firebase/app/dist/index.esm.js
2248  var name2 = "firebase";
2249  var version2 = "9.9.4";
2250  registerVersion(name2, version2, "app");
2251
2252  

2252// node_modules/@firebase/installations/dist/esm/index.esm2017.js
2253  var name3 = "@firebase/installations";
2254  var version3 = "0.5.12";
2255  var PENDING_TIMEOUT_MS = 1e4;
2256  var PACKAGE_VERSION = `w:${version3}`;
2257  var INTERNAL_AUTH_VERSION = "FIS_v2";
2258  var INSTALLATIONS_API_URL = "https://firebaseinstallations.googleapis.com/v1";
2259  var TOKEN_EXPIRATION_BUFFER = 60 * 60 * 1e3;
2260  var SERVICE = "installations";
2261  var SERVICE_NAME = "Installations";
2262  var ERROR_DESCRIPTION_MAP = {
2263    ["missing-app-config-values"]: 'Missing App configuration value: "{$valueName}"',
2264    ["not-registered"]: "Firebase Installation is not registered.",
2265    ["installation-not-found"]: "Firebase Installation not found.",
2266    ["request-failed"]: '{$requestName} request failed with error "{$serverCode} {$serverStatus}: {$serverMessage}"',
2267    ["app-offline"]: "Could not process request. Application offline.",
2268    ["delete-pending-registration"]: "Can't delete installation while there is a pending registration request."
2269  };
2270  var ERROR_FACTORY2 = new ErrorFactory(SERVICE, SERVICE_NAME, ERROR_DESCRIPTION_MAP);
2271  function isServerError(error2) {
2272    return error2 instanceof FirebaseError && error2.code.includes("request-failed");
2273  }
2274  function getInstallationsEndpoint({ projectId }) {
2275    return `${INSTALLATIONS_API_URL}/projects/${projectId}/installations`;
2276  }
2277  function extractAuthTokenInfoFromResponse(response) {
2278    return {
2279      token: response.token,
2280      requestStatus: 2,
2281      expiresIn: getExpiresInFromResponseExpiresIn(response.expiresIn),
2282      creationTime: Date.now()
2283    };
2284  }
2285  async function getErrorFromResponse(requestName, response) {
2286    const responseJson = await response.json();
2287    const errorData = responseJson.error;
2288    return ERROR_FACTORY2.create("request-failed", {
2289      requestName,
2290      serverCode: errorData.code,
2291      serverMessage: errorData.message,
2292      serverStatus: errorData.status
2293    });
2294  }
2295  function getHeaders({ apiKey }) {
2296    return new Headers({
2297      "Content-Type": "application/json",
2298      Accept: "application/json",
2299      "x-goog-api-key": apiKey
2300    });
2301  }
2302  function getHeadersWithAuth(appConfig, { refreshToken }) {
2303    const headers = getHeaders(appConfig);
2304    headers.append("Authorization", getAuthorizationHeader(refreshToken));
2305    return headers;
2306  }
2307  async function retryIfServerError(fn) {
2308    const result = await fn();
2309    if (result.status >= 500 && result.status < 600) {
2310      return fn();
2311    }
2312    return result;
2313  }
2314  function getExpiresInFromResponseExpiresIn(responseExpiresIn) {
2315    return Number(responseExpiresIn.replace("s", "000"));
2316  }
2317  function getAuthorizationHeader(refreshToken) {
2318    return `${INTERNAL_AUTH_VERSION} ${refreshToken}`;
2319  }
2320  async function createInstallationRequest({ appConfig, heartbeatServiceProvider }, { fid }) {
2321    const endpoint = getInstallationsEndpoint(appConfig);
2322    const headers = getHeaders(appConfig);
2323    const heartbeatService = heartbeatServiceProvider.getImmediate({
2324      optional: true
2325    });
2326    if (heartbeatService) {
2327      const heartbeatsHeader = await heartbeatService.getHeartbeatsHeader();
2328      if (heartbeatsHeader) {
2329        headers.append("x-firebase-client", heartbeatsHeader);
2330      }
2331    }
2332    const body = {
2333      fid,
2334      authVersion: INTERNAL_AUTH_VERSION,
2335      appId: appConfig.appId,
2336      sdkVersion: PACKAGE_VERSION
2337    };
2338    const request = {
2339      method: "POST",
2340      headers,
2341      body: JSON.stringify(body)
2342    };
2343    const response = await retryIfServerError(() => fetch(endpoint, request));
2344    if (response.ok) {
2345      const responseValue = await response.json();
2346      const registeredInstallationEntry = {
2347        fid: responseValue.fid || fid,
2348        registrationStatus: 2,
2349        refreshToken: responseValue.refreshToken,
2350        authToken: extractAuthTokenInfoFromResponse(responseValue.authToken)
2351      };
2352      return registeredInstallationEntry;
2353    } else {
2354      throw await getErrorFromResponse("Create Installation", response);
2355    }
2356  }
2357  function sleep(ms) {
2358    return new Promise((resolve) => {
2359      setTimeout(resolve, ms);
2360    });
2361  }
2362  function bufferToBase64UrlSafe(array) {
2363    const b64 = btoa(String.fromCharCode(...array));
2364    return b64.replace(/\+/g, "-").replace(/\//g, "_");
2365  }
2366  var VALID_FID_PATTERN = /^[cdef][\w-]{21}$/;
2367  var INVALID_FID = "";
2368  function generateFid() {
2369    try {
2370      const fidByteArray = new Uint8Array(17);
2371      const crypto = self.crypto || self.msCrypto;
2372      crypto.getRandomValues(fidByteArray);
2373      fidByteArray[0] = 112 + fidByteArray[0] % 16;
2374      const fid = encode(fidByteArray);
2375      return VALID_FID_PATTERN.test(fid) ? fid : INVALID_FID;
2376    } catch (_a) {
2377      return INVALID_FID;
2378    }
2379  }
2380  function encode(fidByteArray) {
2381    const b64String = bufferToBase64UrlSafe(fidByteArray);
2382    return b64String.substr(0, 22);
2383  }
2384  function getKey(appConfig) {
2385    return `${appConfig.appName}!${appConfig.appId}`;
2386  }
2387  var fidChangeCallbacks = /* @__PURE__ */ new Map();
2388  function fidChanged(appConfig, fid) {
2389    const key = getKey(appConfig);
2390    callFidChangeCallbacks(key, fid);
2391    broadcastFidChange(key, fid);
2392  }
2393  function callFidChangeCallbacks(key, fid) {
2394    const callbacks = fidChangeCallbacks.get(key);
2395    if (!callbacks) {
2396      return;
2397    }
2398    for (const callback of callbacks) {
2399      callback(fid);
2400    }
2401  }
2402  function broadcastFidChange(key, fid) {
2403    const channel = getBroadcastChannel();
2404    if (channel) {
2405      channel.postMessage({ key, fid });
2406    }
2407    closeBroadcastChannel();
2408  }
2409  var broadcastChannel = null;
2410  function getBroadcastChannel() {
2411    if (!broadcastChannel && "BroadcastChannel" in self) {
2412      broadcastChannel = new BroadcastChannel("[Firebase] FID Change");
2413      broadcastChannel.onmessage = (e) => {
2414        callFidChangeCallbacks(e.data.key, e.data.fid);
2415      };
2416    }
2417    return broadcastChannel;
2418  }
2419  function closeBroadcastChannel() {
2420    if (fidChangeCallbacks.size === 0 && broadcastChannel) {
2421      broadcastChannel.close();
2422      broadcastChannel = null;
2423    }
2424  }
2425  var DATABASE_NAME = "firebase-installations-database";
2426  var DATABASE_VERSION = 1;
2427  var OBJECT_STORE_NAME = "firebase-installations-store";
2428  var dbPromise2 = null;
2429  function getDbPromise2() {
2430    if (!dbPromise2) {
2431      dbPromise2 = openDB(DATABASE_NAME, DATABASE_VERSION, {
2432        upgrade: (db2, oldVersion) => {
2433          switch (oldVersion) {
2434            case 0:
2435              db2.createObjectStore(OBJECT_STORE_NAME);
2436          }
2437        }
2438      });
2439    }
2440    return dbPromise2;
2441  }
2442  async function set(appConfig, value) {
2443    const key = getKey(appConfig);
2444    const db2 = await getDbPromise2();
2445    const tx = db2.transaction(OBJECT_STORE_NAME, "readwrite");
2446    const objectStore = tx.objectStore(OBJECT_STORE_NAME);
2447    const oldValue = await objectStore.get(key);
2448    await objectStore.put(value, key);
2449    await tx.done;
2450    if (!oldValue || oldValue.fid !== value.fid) {
2451      fidChanged(appConfig, value.fid);
2452    }
2453    return value;
2454  }
2455  async function remove(appConfig) {
2456    const key = getKey(appConfig);
2457    const db2 = await getDbPromise2();
2458    const tx = db2.transaction(OBJECT_STORE_NAME, "readwrite");
2459    await tx.objectStore(OBJECT_STORE_NAME).delete(key);
2460    await tx.done;
2461  }
2462  async function update(appConfig, updateFn) {
2463    const key = getKey(appConfig);
2464    const db2 = await getDbPromise2();
2465    const tx = db2.transaction(OBJECT_STORE_NAME, "readwrite");
2466    const store = tx.objectStore(OBJECT_STORE_NAME);
2467    const oldValue = await store.get(key);
2468    const newValue = updateFn(oldValue);
2469    if (newValue === void 0) {
2470      await store.delete(key);
2471    } else {
2472      await store.put(newValue, key);
2473    }
2474    await tx.done;
2475    if (newValue && (!oldValue || oldValue.fid !== newValue.fid)) {
2476      fidChanged(appConfig, newValue.fid);
2477    }
2478    return newValue;
2479  }
2480  async function getInstallationEntry(installations) {
2481    let registrationPromise;
2482    const installationEntry = await update(installations.appConfig, (oldEntry) => {
2483      const installationEntry2 = updateOrCreateInstallationEntry(oldEntry);
2484      const entryWithPromise = triggerRegistrationIfNecessary(installations, installationEntry2);
2485      registrationPromise = entryWithPromise.registrationPromise;
2486      return entryWithPromise.installationEntry;
2487    });
2488    if (installationEntry.fid === INVALID_FID) {
2489      return { installationEntry: await registrationPromise };
2490    }
2491    return {
2492      installationEntry,
2493      registrationPromise
2494    };
2495  }
2496  function updateOrCreateInstallationEntry(oldEntry) {
2497    const entry = oldEntry || {
2498      fid: generateFid(),
2499      registrationStatus: 0
2500    };
2501    return clearTimedOutRequest(entry);
2502  }
2503  function triggerRegistrationIfNecessary(installations, installationEntry) {
2504    if (installationEntry.registrationStatus === 0) {
2505      if (!navigator.onLine) {
2506        const registrationPromiseWithError = Promise.reject(ERROR_FACTORY2.create("app-offline"));
2507        return {
2508          installationEntry,
2509          registrationPromise: registrationPromiseWithError
2510        };
2511      }
2512      const inProgressEntry = {
2513        fid: installationEntry.fid,
2514        registrationStatus: 1,
2515        registrationTime: Date.now()
2516      };
2517      const registrationPromise = registerInstallation(installations, inProgressEntry);
2518      return { installationEntry: inProgressEntry, registrationPromise };
2519    } else if (installationEntry.registrationStatus === 1) {
2520      return {
2521        installationEntry,
2522        registrationPromise: waitUntilFidRegistration(installations)
2523      };
2524    } else {
2525      return { installationEntry };
2526    }
2527  }
2528  async function registerInstallation(installations, installationEntry) {
2529    try {
2530      const registeredInstallationEntry = await createInstallationRequest(installations, installationEntry);
2531      return set(installations.appConfig, registeredInstallationEntry);
2532    } catch (e) {
2533      if (isServerError(e) && e.customData.serverCode === 409) {
2534        await remove(installations.appConfig);
2535      } else {
2536        await set(installations.appConfig, {
2537          fid: installationEntry.fid,
2538          registrationStatus: 0
2539        });
2540      }
2541      throw e;
2542    }
2543  }
2544  async function waitUntilFidRegistration(installations) {
2545    let entry = await updateInstallationRequest(installations.appConfig);
2546    while (entry.registrationStatus === 1) {
2547      await sleep(100);
2548      entry = await updateInstallationRequest(installations.appConfig);
2549    }
2550    if (entry.registrationStatus === 0) {
2551      const { installationEntry, registrationPromise } = await getInstallationEntry(installations);
2552      if (registrationPromise) {
2553        return registrationPromise;
2554      } else {
2555        return installationEntry;
2556      }
2557    }
2558    return entry;
2559  }
2560  function updateInstallationRequest(appConfig) {
2561    return update(appConfig, (oldEntry) => {
2562      if (!oldEntry) {
2563        throw ERROR_FACTORY2.create("installation-not-found");
2564      }
2565      return clearTimedOutRequest(oldEntry);
2566    });
2567  }
2568  function clearTimedOutRequest(entry) {
2569    if (hasInstallationRequestTimedOut(entry)) {
2570      return {
2571        fid: entry.fid,
2572        registrationStatus: 0
2573      };
2574    }
2575    return entry;
2576  }
2577  function hasInstallationRequestTimedOut(installationEntry) {
2578    return installationEntry.registrationStatus === 1 && installationEntry.registrationTime + PENDING_TIMEOUT_MS < Date.now();
2579  }
2580  async function generateAuthTokenRequest({ appConfig, heartbeatServiceProvider }, installationEntry) {
2581    const endpoint = getGenerateAuthTokenEndpoint(appConfig, installationEntry);
2582    const headers = getHeadersWithAuth(appConfig, installationEntry);
2583    const heartbeatService = heartbeatServiceProvider.getImmediate({
2584      optional: true
2585    });
2586    if (heartbeatService) {
2587      const heartbeatsHeader = await heartbeatService.getHeartbeatsHeader();
2588      if (heartbeatsHeader) {
2589        headers.append("x-firebase-client", heartbeatsHeader);
2590      }
2591    }
2592    const body = {
2593      installation: {
2594        sdkVersion: PACKAGE_VERSION,
2595        appId: appConfig.appId
2596      }
2597    };
2598    const request = {
2599      method: "POST",
2600      headers,
2601      body: JSON.stringify(body)
2602    };
2603    const response = await retryIfServerError(() => fetch(endpoint, request));
2604    if (response.ok) {
2605      const responseValue = await response.json();
2606      const completedAuthToken = extractAuthTokenInfoFromResponse(responseValue);
2607      return completedAuthToken;
2608    } else {
2609      throw await getErrorFromResponse("Generate Auth Token", response);
2610    }
2611  }
2612  function getGenerateAuthTokenEndpoint(appConfig, { fid }) {
2613    return `${getInstallationsEndpoint(appConfig)}/${fid}/authTokens:generate`;
2614  }
2615  async function refreshAuthToken(installations, forceRefresh = false) {
2616    let tokenPromise;
2617    const entry = await update(installations.appConfig, (oldEntry) => {
2618      if (!isEntryRegistered(oldEntry)) {
2619        throw ERROR_FACTORY2.create("not-registered");
2620      }
2621      const oldAuthToken = oldEntry.authToken;
2622      if (!forceRefresh && isAuthTokenValid(oldAuthToken)) {
2623        return oldEntry;
2624      } else if (oldAuthToken.requestStatus === 1) {
2625        tokenPromise = waitUntilAuthTokenRequest(installations, forceRefresh);
2626        return oldEntry;
2627      } else {
2628        if (!navigator.onLine) {
2629          throw ERROR_FACTORY2.create("app-offline");
2630        }
2631        const inProgressEntry = makeAuthTokenRequestInProgressEntry(oldEntry);
2632        tokenPromise = fetchAuthTokenFromServer(installations, inProgressEntry);
2633        return inProgressEntry;
2634      }
2635    });
2636    const authToken = tokenPromise ? await tokenPromise : entry.authToken;
2637    return authToken;
2638  }
2639  async function waitUntilAuthTokenRequest(installations, forceRefresh) {
2640    let entry = await updateAuthTokenRequest(installations.appConfig);
2641    while (entry.authToken.requestStatus === 1) {
2642      await sleep(100);
2643      entry = await updateAuthTokenRequest(installations.appConfig);
2644    }
2645    const authToken = entry.authToken;
2646    if (authToken.requestStatus === 0) {
2647      return refreshAuthToken(installations, forceRefresh);
2648    } else {
2649      return authToken;
2650    }
2651  }
2652  function updateAuthTokenRequest(appConfig) {
2653    return update(appConfig, (oldEntry) => {
2654      if (!isEntryRegistered(oldEntry)) {
2655        throw ERROR_FACTORY2.create("not-registered");
2656      }
2657      const oldAuthToken = oldEntry.authToken;
2658      if (hasAuthTokenRequestTimedOut(oldAuthToken)) {
2659        return Object.assign(Object.assign({}, oldEntry), { authToken: { requestStatus: 0 } });
2660      }
2661      return oldEntry;
2662    });
2663  }
2664  async function fetchAuthTokenFromServer(installations, installationEntry) {
2665    try {
2666      const authToken = await generateAuthTokenRequest(installations, installationEntry);
2667      const updatedInstallationEntry = Object.assign(Object.assign({}, installationEntry), { authToken });
2668      await set(installations.appConfig, updatedInstallationEntry);
2669      return authToken;
2670    } catch (e) {
2671      if (isServerError(e) && (e.customData.serverCode === 401 || e.customData.serverCode === 404)) {
2672        await remove(installations.appConfig);
2673      } else {
2674        const updatedInstallationEntry = Object.assign(Object.assign({}, installationEntry), { authToken: { requestStatus: 0 } });
2675        await set(installations.appConfig, updatedInstallationEntry);
2676      }
2677      throw e;
2678    }
2679  }
2680  function isEntryRegistered(installationEntry) {
2681    return installationEntry !== void 0 && installationEntry.registrationStatus === 2;
2682  }
2683  function isAuthTokenValid(authToken) {
2684    return authToken.requestStatus === 2 && !isAuthTokenExpired(authToken);
2685  }
2686  function isAuthTokenExpired(authToken) {
2687    const now = Date.now();
2688    return now < authToken.creationTime || authToken.creationTime + authToken.expiresIn < now + TOKEN_EXPIRATION_BUFFER;
2689  }
2690  function makeAuthTokenRequestInProgressEntry(oldEntry) {
2691    const inProgressAuthToken = {
2692      requestStatus: 1,
2693      requestTime: Date.now()
2694    };
2695    return Object.assign(Object.assign({}, oldEntry), { authToken: inProgressAuthToken });
2696  }
2697  function hasAuthTokenRequestTimedOut(authToken) {
2698    return authToken.requestStatus === 1 && authToken.requestTime + PENDING_TIMEOUT_MS < Date.now();
2699  }
2700  async function getId(installations) {
2701    const installationsImpl = installations;
2702    const { installationEntry, registrationPromise } = await getInstallationEntry(installationsImpl);
2703    if (registrationPromise) {
2704      registrationPromise.catch(console.error);
2705    } else {
2706      refreshAuthToken(installationsImpl).catch(console.error);
2707    }
2708    return installationEntry.fid;
2709  }
2710  async function getToken(installations, forceRefresh = false) {
2711    const installationsImpl = installations;
2712    await completeInstallationRegistration(installationsImpl);
2713    const authToken = await refreshAuthToken(installationsImpl, forceRefresh);
2714    return authToken.token;
2715  }
2716  async function completeInstallationRegistration(installations) {
2717    const { registrationPromise } = await getInstallationEntry(installations);
2718    if (registrationPromise) {
2719      await registrationPromise;
2720    }
2721  }
2722  function extractAppConfig(app2) {
2723    if (!app2 || !app2.options) {
2724      throw getMissingValueError("App Configuration");
2725    }
2726    if (!app2.name) {
2727      throw getMissingValueError("App Name");
2728    }
2729    const configKeys = [
2730      "projectId",
2731      "apiKey",
2732      "appId"
2733    ];
2734    for (const keyName of configKeys) {
2735      if (!app2.options[keyName]) {
2736        throw getMissingValueError(keyName);
2737      }
2738    }
2739    return {
2740      appName: app2.name,
2741      projectId: app2.options.projectId,
2742      apiKey: app2.options.apiKey,
2743      appId: app2.options.appId
2744    };
2745  }
2746  function getMissingValueError(valueName) {
2747    return ERROR_FACTORY2.create("missing-app-config-values", {
2748      valueName
2749    });
2750  }
2751  var INSTALLATIONS_NAME = "installations";
2752  var INSTALLATIONS_NAME_INTERNAL = "installations-internal";
2753  var publicFactory = (container) => {
2754    const app2 = container.getProvider("app").getImmediate();
2755    const appConfig = extractAppConfig(app2);
2756    const heartbeatServiceProvider = _getProvider(app2, "heartbeat");
2757    const installationsImpl = {
2758      app: app2,
2759      appConfig,
2760      heartbeatServiceProvider,
2761      _delete: () => Promise.resolve()
2762    };
2763    return installationsImpl;
2764  };
2765  var internalFactory = (container) => {
2766    const app2 = container.getProvider("app").getImmediate();
2767    const installations = _getProvider(app2, INSTALLATIONS_NAME).getImmediate();
2768    const installationsInternal = {
2769      getId: () => getId(installations),
2770      getToken: (forceRefresh) => getToken(installations, forceRefresh)
2771    };
2772    return installationsInternal;
2773  };
2774  function registerInstallations() {
2775    _registerComponent(new Component(INSTALLATIONS_NAME, publicFactory, "PUBLIC"));
2776    _registerComponent(new Component(INSTALLATIONS_NAME_INTERNAL, internalFactory, "PRIVATE"));
2777  }
2778  registerInstallations();
2779  registerVersion(name3, version3);
2780  registerVersion(name3, version3, "esm2017");
2781
2782