@feedmepos/mf-financing 0.0.2

package/dist/app.js

@@ -0,0 +1,3687 @@
+import { createRouter as ht, createWebHistory as dt, useRoute as ut } from "vue-router";
+import { computed as ft, defineComponent as pt, onMounted as mt, resolveComponent as gt, openBlock as _t, createBlock as bt, unref as vt } from "vue";
+import { defineStore as It } from "pinia";
+import { useCoreStore as yt } from "@feedmepos/mf-common";
+const Et = {}, wt = {
+  financing: Et
+}, St = {}, At = {
+  financing: St
+}, Tt = ht({
+  history: dt(),
+  routes: [
+    {
+      path: "/",
+      name: "mf-financing",
+      component: () => import("./Financing-6bpYBvrC.js")
+    },
+    {
+      path: "/forbidden",
+      name: "mf-financing-forbidden",
+      component: () => import("./Forbidden-Dqw0MqyC.js")
+    }
+  ]
+}), Ct = It("mf-financing-iframe", () => {
+  const r = {
+    isIframe: !1
+  }, e = ft(() => r);
+  function t(n) {
+    r.isIframe = n;
+  }
+  return {
+    state: e,
+    init: t
+  };
+});
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const Be = function(r) {
+  const e = [];
+  let t = 0;
+  for (let n = 0; n < r.length; n++) {
+    let i = r.charCodeAt(n);
+    i < 128 ? e[t++] = i : i < 2048 ? (e[t++] = i >> 6 | 192, e[t++] = i & 63 | 128) : (i & 64512) === 55296 && n + 1 < r.length && (r.charCodeAt(n + 1) & 64512) === 56320 ? (i = 65536 + ((i & 1023) << 10) + (r.charCodeAt(++n) & 1023), e[t++] = i >> 18 | 240, e[t++] = i >> 12 & 63 | 128, e[t++] = i >> 6 & 63 | 128, e[t++] = i & 63 | 128) : (e[t++] = i >> 12 | 224, e[t++] = i >> 6 & 63 | 128, e[t++] = i & 63 | 128);
+  }
+  return e;
+}, Nt = function(r) {
+  const e = [];
+  let t = 0, n = 0;
+  for (; t < r.length; ) {
+    const i = r[t++];
+    if (i < 128)
+      e[n++] = String.fromCharCode(i);
+    else if (i > 191 && i < 224) {
+      const s = r[t++];
+      e[n++] = String.fromCharCode((i & 31) << 6 | s & 63);
+    } else if (i > 239 && i < 365) {
+      const s = r[t++], a = r[t++], c = r[t++], o = ((i & 7) << 18 | (s & 63) << 12 | (a & 63) << 6 | c & 63) - 65536;
+      e[n++] = String.fromCharCode(55296 + (o >> 10)), e[n++] = String.fromCharCode(56320 + (o & 1023));
+    } else {
+      const s = r[t++], a = r[t++];
+      e[n++] = String.fromCharCode((i & 15) << 12 | (s & 63) << 6 | a & 63);
+    }
+  }
+  return e.join("");
+}, xe = {
+  /**
+   * Maps bytes to characters.
+   */
+  byteToCharMap_: null,
+  /**
+   * Maps characters to bytes.
+   */
+  charToByteMap_: null,
+  /**
+   * Maps bytes to websafe characters.
+   * @private
+   */
+  byteToCharMapWebSafe_: null,
+  /**
+   * Maps websafe characters to bytes.
+   * @private
+   */
+  charToByteMapWebSafe_: null,
+  /**
+   * Our default alphabet, shared between
+   * ENCODED_VALS and ENCODED_VALS_WEBSAFE
+   */
+  ENCODED_VALS_BASE: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+  /**
+   * Our default alphabet. Value 64 (=) is special; it means "nothing."
+   */
+  get ENCODED_VALS() {
+    return this.ENCODED_VALS_BASE + "+/=";
+  },
+  /**
+   * Our websafe alphabet.
+   */
+  get ENCODED_VALS_WEBSAFE() {
+    return this.ENCODED_VALS_BASE + "-_.";
+  },
+  /**
+   * Whether this browser supports the atob and btoa functions. This extension
+   * started at Mozilla but is now implemented by many browsers. We use the
+   * ASSUME_* variables to avoid pulling in the full useragent detection library
+   * but still allowing the standard per-browser compilations.
+   *
+   */
+  HAS_NATIVE_SUPPORT: typeof atob == "function",
+  /**
+   * Base64-encode an array of bytes.
+   *
+   * @param input An array of bytes (numbers with
+   *     value in [0, 255]) to encode.
+   * @param webSafe Boolean indicating we should use the
+   *     alternative alphabet.
+   * @return The base64 encoded string.
+   */
+  encodeByteArray(r, e) {
+    if (!Array.isArray(r))
+      throw Error("encodeByteArray takes an array as a parameter");
+    this.init_();
+    const t = e ? this.byteToCharMapWebSafe_ : this.byteToCharMap_, n = [];
+    for (let i = 0; i < r.length; i += 3) {
+      const s = r[i], a = i + 1 < r.length, c = a ? r[i + 1] : 0, o = i + 2 < r.length, l = o ? r[i + 2] : 0, u = s >> 2, f = (s & 3) << 4 | c >> 4;
+      let v = (c & 15) << 2 | l >> 6, I = l & 63;
+      o || (I = 64, a || (v = 64)), n.push(t[u], t[f], t[v], t[I]);
+    }
+    return n.join("");
+  },
+  /**
+   * Base64-encode a string.
+   *
+   * @param input A string to encode.
+   * @param webSafe If true, we should use the
+   *     alternative alphabet.
+   * @return The base64 encoded string.
+   */
+  encodeString(r, e) {
+    return this.HAS_NATIVE_SUPPORT && !e ? btoa(r) : this.encodeByteArray(Be(r), e);
+  },
+  /**
+   * Base64-decode a string.
+   *
+   * @param input to decode.
+   * @param webSafe True if we should use the
+   *     alternative alphabet.
+   * @return string representing the decoded value.
+   */
+  decodeString(r, e) {
+    return this.HAS_NATIVE_SUPPORT && !e ? atob(r) : Nt(this.decodeStringToByteArray(r, e));
+  },
+  /**
+   * Base64-decode a string.
+   *
+   * In base-64 decoding, groups of four characters are converted into three
+   * bytes.  If the encoder did not apply padding, the input length may not
+   * be a multiple of 4.
+   *
+   * In this case, the last group will have fewer than 4 characters, and
+   * padding will be inferred.  If the group has one or two characters, it decodes
+   * to one byte.  If the group has three characters, it decodes to two bytes.
+   *
+   * @param input Input to decode.
+   * @param webSafe True if we should use the web-safe alphabet.
+   * @return bytes representing the decoded value.
+   */
+  decodeStringToByteArray(r, e) {
+    this.init_();
+    const t = e ? this.charToByteMapWebSafe_ : this.charToByteMap_, n = [];
+    for (let i = 0; i < r.length; ) {
+      const s = t[r.charAt(i++)], c = i < r.length ? t[r.charAt(i)] : 0;
+      ++i;
+      const l = i < r.length ? t[r.charAt(i)] : 64;
+      ++i;
+      const f = i < r.length ? t[r.charAt(i)] : 64;
+      if (++i, s == null || c == null || l == null || f == null)
+        throw new Dt();
+      const v = s << 2 | c >> 4;
+      if (n.push(v), l !== 64) {
+        const I = c << 4 & 240 | l >> 2;
+        if (n.push(I), f !== 64) {
+          const M = l << 6 & 192 | f;
+          n.push(M);
+        }
+      }
+    }
+    return n;
+  },
+  /**
+   * Lazy static initialization function. Called before
+   * accessing any of the static map variables.
+   * @private
+   */
+  init_() {
+    if (!this.byteToCharMap_) {
+      this.byteToCharMap_ = {}, this.charToByteMap_ = {}, this.byteToCharMapWebSafe_ = {}, this.charToByteMapWebSafe_ = {};
+      for (let r = 0; r < this.ENCODED_VALS.length; r++)
+        this.byteToCharMap_[r] = this.ENCODED_VALS.charAt(r), this.charToByteMap_[this.byteToCharMap_[r]] = r, this.byteToCharMapWebSafe_[r] = this.ENCODED_VALS_WEBSAFE.charAt(r), this.charToByteMapWebSafe_[this.byteToCharMapWebSafe_[r]] = r, r >= this.ENCODED_VALS_BASE.length && (this.charToByteMap_[this.ENCODED_VALS_WEBSAFE.charAt(r)] = r, this.charToByteMapWebSafe_[this.ENCODED_VALS.charAt(r)] = r);
+    }
+  }
+};
+class Dt extends Error {
+  constructor() {
+    super(...arguments), this.name = "DecodeBase64StringError";
+  }
+}
+const Ot = function(r) {
+  const e = Be(r);
+  return xe.encodeByteArray(e, !0);
+}, Fe = function(r) {
+  return Ot(r).replace(/\./g, "");
+}, $e = function(r) {
+  try {
+    return xe.decodeString(r, !0);
+  } catch (e) {
+    console.error("base64Decode failed: ", e);
+  }
+  return null;
+};
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function kt() {
+  if (typeof self < "u")
+    return self;
+  if (typeof window < "u")
+    return window;
+  if (typeof global < "u")
+    return global;
+  throw new Error("Unable to locate global object.");
+}
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const Pt = () => kt().__FIREBASE_DEFAULTS__, Rt = () => {
+  if (typeof process > "u" || typeof process.env > "u")
+    return;
+  const r = process.env.__FIREBASE_DEFAULTS__;
+  if (r)
+    return JSON.parse(r);
+}, Lt = () => {
+  if (typeof document > "u")
+    return;
+  let r;
+  try {
+    r = document.cookie.match(/__FIREBASE_DEFAULTS__=([^;]+)/);
+  } catch {
+    return;
+  }
+  const e = r && $e(r[1]);
+  return e && JSON.parse(e);
+}, Ve = () => {
+  try {
+    return Pt() || Rt() || Lt();
+  } catch (r) {
+    console.info(`Unable to get __FIREBASE_DEFAULTS__ due to: ${r}`);
+    return;
+  }
+}, Ut = () => {
+  var r;
+  return (r = Ve()) === null || r === void 0 ? void 0 : r.config;
+}, Mt = (r) => {
+  var e;
+  return (e = Ve()) === null || e === void 0 ? void 0 : e[`_${r}`];
+};
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Bt {
+  constructor() {
+    this.reject = () => {
+    }, this.resolve = () => {
+    }, this.promise = new Promise((e, t) => {
+      this.resolve = e, this.reject = t;
+    });
+  }
+  /**
+   * Our API internals are not promisified and cannot because our callback APIs have subtle expectations around
+   * invoking promises inline, which Promises are forbidden to do. This method accepts an optional node-style callback
+   * and returns a node-style callback which will resolve or reject the Deferred's promise.
+   */
+  wrapCallback(e) {
+    return (t, n) => {
+      t ? this.reject(t) : this.resolve(n), typeof e == "function" && (this.promise.catch(() => {
+      }), e.length === 1 ? e(t) : e(t, n));
+    };
+  }
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function p() {
+  return typeof navigator < "u" && typeof navigator.userAgent == "string" ? navigator.userAgent : "";
+}
+function xt() {
+  return typeof window < "u" && // @ts-ignore Setting up an broadly applicable index signature for Window
+  // just to deal with this case would probably be a bad idea.
+  !!(window.cordova || window.phonegap || window.PhoneGap) && /ios|iphone|ipod|ipad|android|blackberry|iemobile/i.test(p());
+}
+function Ft() {
+  return typeof navigator < "u" && navigator.userAgent === "Cloudflare-Workers";
+}
+function $t() {
+  const r = typeof chrome == "object" ? chrome.runtime : typeof browser == "object" ? browser.runtime : void 0;
+  return typeof r == "object" && r.id !== void 0;
+}
+function Vt() {
+  return typeof navigator == "object" && navigator.product === "ReactNative";
+}
+function Ht() {
+  try {
+    return typeof indexedDB == "object";
+  } catch {
+    return !1;
+  }
+}
+function zt() {
+  return new Promise((r, e) => {
+    try {
+      let t = !0;
+      const n = "validate-browser-context-for-indexeddb-analytics-module", i = self.indexedDB.open(n);
+      i.onsuccess = () => {
+        i.result.close(), t || self.indexedDB.deleteDatabase(n), r(!0);
+      }, i.onupgradeneeded = () => {
+        t = !1;
+      }, i.onerror = () => {
+        var s;
+        e(((s = i.error) === null || s === void 0 ? void 0 : s.message) || "");
+      };
+    } catch (t) {
+      e(t);
+    }
+  });
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const jt = "FirebaseError";
+class S extends Error {
+  constructor(e, t, n) {
+    super(t), this.code = e, this.customData = n, this.name = jt, Object.setPrototypeOf(this, S.prototype), Error.captureStackTrace && Error.captureStackTrace(this, L.prototype.create);
+  }
+}
+class L {
+  constructor(e, t, n) {
+    this.service = e, this.serviceName = t, this.errors = n;
+  }
+  create(e, ...t) {
+    const n = t[0] || {}, i = `${this.service}/${e}`, s = this.errors[e], a = s ? Wt(s, n) : "Error", c = `${this.serviceName}: ${a} (${i}).`;
+    return new S(i, c, n);
+  }
+}
+function Wt(r, e) {
+  return r.replace(Gt, (t, n) => {
+    const i = e[n];
+    return i != null ? String(i) : `<${n}?>`;
+  });
+}
+const Gt = /\{\$([^}]+)}/g;
+function re(r, e) {
+  if (r === e)
+    return !0;
+  const t = Object.keys(r), n = Object.keys(e);
+  for (const i of t) {
+    if (!n.includes(i))
+      return !1;
+    const s = r[i], a = e[i];
+    if (ve(s) && ve(a)) {
+      if (!re(s, a))
+        return !1;
+    } else if (s !== a)
+      return !1;
+  }
+  for (const i of n)
+    if (!t.includes(i))
+      return !1;
+  return !0;
+}
+function ve(r) {
+  return r !== null && typeof r == "object";
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function He(r) {
+  const e = [];
+  for (const [t, n] of Object.entries(r))
+    Array.isArray(n) ? n.forEach((i) => {
+      e.push(encodeURIComponent(t) + "=" + encodeURIComponent(i));
+    }) : e.push(encodeURIComponent(t) + "=" + encodeURIComponent(n));
+  return e.length ? "&" + e.join("&") : "";
+}
+function Kt(r, e) {
+  const t = new Jt(r, e);
+  return t.subscribe.bind(t);
+}
+class Jt {
+  /**
+   * @param executor Function which can make calls to a single Observer
+   *     as a proxy.
+   * @param onNoObservers Callback when count of Observers goes to zero.
+   */
+  constructor(e, t) {
+    this.observers = [], this.unsubscribes = [], this.observerCount = 0, this.task = Promise.resolve(), this.finalized = !1, this.onNoObservers = t, this.task.then(() => {
+      e(this);
+    }).catch((n) => {
+      this.error(n);
+    });
+  }
+  next(e) {
+    this.forEachObserver((t) => {
+      t.next(e);
+    });
+  }
+  error(e) {
+    this.forEachObserver((t) => {
+      t.error(e);
+    }), this.close(e);
+  }
+  complete() {
+    this.forEachObserver((e) => {
+      e.complete();
+    }), this.close();
+  }
+  /**
+   * Subscribe function that can be used to add an Observer to the fan-out list.
+   *
+   * - We require that no event is sent to a subscriber synchronously to their
+   *   call to subscribe().
+   */
+  subscribe(e, t, n) {
+    let i;
+    if (e === void 0 && t === void 0 && n === void 0)
+      throw new Error("Missing Observer.");
+    qt(e, [
+      "next",
+      "error",
+      "complete"
+    ]) ? i = e : i = {
+      next: e,
+      error: t,
+      complete: n
+    }, i.next === void 0 && (i.next = q), i.error === void 0 && (i.error = q), i.complete === void 0 && (i.complete = q);
+    const s = this.unsubscribeOne.bind(this, this.observers.length);
+    return this.finalized && this.task.then(() => {
+      try {
+        this.finalError ? i.error(this.finalError) : i.complete();
+      } catch {
+      }
+    }), this.observers.push(i), s;
+  }
+  // Unsubscribe is synchronous - we guarantee that no events are sent to
+  // any unsubscribed Observer.
+  unsubscribeOne(e) {
+    this.observers === void 0 || this.observers[e] === void 0 || (delete this.observers[e], this.observerCount -= 1, this.observerCount === 0 && this.onNoObservers !== void 0 && this.onNoObservers(this));
+  }
+  forEachObserver(e) {
+    if (!this.finalized)
+      for (let t = 0; t < this.observers.length; t++)
+        this.sendOne(t, e);
+  }
+  // Call the Observer via one of it's callback function. We are careful to
+  // confirm that the observe has not been unsubscribed since this asynchronous
+  // function had been queued.
+  sendOne(e, t) {
+    this.task.then(() => {
+      if (this.observers !== void 0 && this.observers[e] !== void 0)
+        try {
+          t(this.observers[e]);
+        } catch (n) {
+          typeof console < "u" && console.error && console.error(n);
+        }
+    });
+  }
+  close(e) {
+    this.finalized || (this.finalized = !0, e !== void 0 && (this.finalError = e), this.task.then(() => {
+      this.observers = void 0, this.onNoObservers = void 0;
+    }));
+  }
+}
+function qt(r, e) {
+  if (typeof r != "object" || r === null)
+    return !1;
+  for (const t of e)
+    if (t in r && typeof r[t] == "function")
+      return !0;
+  return !1;
+}
+function q() {
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function z(r) {
+  return r && r._delegate ? r._delegate : r;
+}
+class N {
+  /**
+   *
+   * @param name The public service name, e.g. app, auth, firestore, database
+   * @param instanceFactory Service factory responsible for creating the public interface
+   * @param type whether the service provided by the component is public or private
+   */
+  constructor(e, t, n) {
+    this.name = e, this.instanceFactory = t, this.type = n, this.multipleInstances = !1, this.serviceProps = {}, this.instantiationMode = "LAZY", this.onInstanceCreated = null;
+  }
+  setInstantiationMode(e) {
+    return this.instantiationMode = e, this;
+  }
+  setMultipleInstances(e) {
+    return this.multipleInstances = e, this;
+  }
+  setServiceProps(e) {
+    return this.serviceProps = e, this;
+  }
+  setInstanceCreatedCallback(e) {
+    return this.onInstanceCreated = e, this;
+  }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const y = "[DEFAULT]";
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Xt {
+  constructor(e, t) {
+    this.name = e, this.container = t, this.component = null, this.instances = /* @__PURE__ */ new Map(), this.instancesDeferred = /* @__PURE__ */ new Map(), this.instancesOptions = /* @__PURE__ */ new Map(), this.onInitCallbacks = /* @__PURE__ */ new Map();
+  }
+  /**
+   * @param identifier A provider can provide multiple instances of a service
+   * if this.component.multipleInstances is true.
+   */
+  get(e) {
+    const t = this.normalizeInstanceIdentifier(e);
+    if (!this.instancesDeferred.has(t)) {
+      const n = new Bt();
+      if (this.instancesDeferred.set(t, n), this.isInitialized(t) || this.shouldAutoInitialize())
+        try {
+          const i = this.getOrInitializeService({
+            instanceIdentifier: t
+          });
+          i && n.resolve(i);
+        } catch {
+        }
+    }
+    return this.instancesDeferred.get(t).promise;
+  }
+  getImmediate(e) {
+    var t;
+    const n = this.normalizeInstanceIdentifier(e == null ? void 0 : e.identifier), i = (t = e == null ? void 0 : e.optional) !== null && t !== void 0 ? t : !1;
+    if (this.isInitialized(n) || this.shouldAutoInitialize())
+      try {
+        return this.getOrInitializeService({
+          instanceIdentifier: n
+        });
+      } catch (s) {
+        if (i)
+          return null;
+        throw s;
+      }
+    else {
+      if (i)
+        return null;
+      throw Error(`Service ${this.name} is not available`);
+    }
+  }
+  getComponent() {
+    return this.component;
+  }
+  setComponent(e) {
+    if (e.name !== this.name)
+      throw Error(`Mismatching Component ${e.name} for Provider ${this.name}.`);
+    if (this.component)
+      throw Error(`Component for ${this.name} has already been provided`);
+    if (this.component = e, !!this.shouldAutoInitialize()) {
+      if (Qt(e))
+        try {
+          this.getOrInitializeService({ instanceIdentifier: y });
+        } catch {
+        }
+      for (const [t, n] of this.instancesDeferred.entries()) {
+        const i = this.normalizeInstanceIdentifier(t);
+        try {
+          const s = this.getOrInitializeService({
+            instanceIdentifier: i
+          });
+          n.resolve(s);
+        } catch {
+        }
+      }
+    }
+  }
+  clearInstance(e = y) {
+    this.instancesDeferred.delete(e), this.instancesOptions.delete(e), this.instances.delete(e);
+  }
+  // app.delete() will call this method on every provider to delete the services
+  // TODO: should we mark the provider as deleted?
+  async delete() {
+    const e = Array.from(this.instances.values());
+    await Promise.all([
+      ...e.filter((t) => "INTERNAL" in t).map((t) => t.INTERNAL.delete()),
+      ...e.filter((t) => "_delete" in t).map((t) => t._delete())
+    ]);
+  }
+  isComponentSet() {
+    return this.component != null;
+  }
+  isInitialized(e = y) {
+    return this.instances.has(e);
+  }
+  getOptions(e = y) {
+    return this.instancesOptions.get(e) || {};
+  }
+  initialize(e = {}) {
+    const { options: t = {} } = e, n = this.normalizeInstanceIdentifier(e.instanceIdentifier);
+    if (this.isInitialized(n))
+      throw Error(`${this.name}(${n}) has already been initialized`);
+    if (!this.isComponentSet())
+      throw Error(`Component ${this.name} has not been registered yet`);
+    const i = this.getOrInitializeService({
+      instanceIdentifier: n,
+      options: t
+    });
+    for (const [s, a] of this.instancesDeferred.entries()) {
+      const c = this.normalizeInstanceIdentifier(s);
+      n === c && a.resolve(i);
+    }
+    return i;
+  }
+  /**
+   *
+   * @param callback - a function that will be invoked  after the provider has been initialized by calling provider.initialize().
+   * The function is invoked SYNCHRONOUSLY, so it should not execute any longrunning tasks in order to not block the program.
+   *
+   * @param identifier An optional instance identifier
+   * @returns a function to unregister the callback
+   */
+  onInit(e, t) {
+    var n;
+    const i = this.normalizeInstanceIdentifier(t), s = (n = this.onInitCallbacks.get(i)) !== null && n !== void 0 ? n : /* @__PURE__ */ new Set();
+    s.add(e), this.onInitCallbacks.set(i, s);
+    const a = this.instances.get(i);
+    return a && e(a, i), () => {
+      s.delete(e);
+    };
+  }
+  /**
+   * Invoke onInit callbacks synchronously
+   * @param instance the service instance`
+   */
+  invokeOnInitCallbacks(e, t) {
+    const n = this.onInitCallbacks.get(t);
+    if (n)
+      for (const i of n)
+        try {
+          i(e, t);
+        } catch {
+        }
+  }
+  getOrInitializeService({ instanceIdentifier: e, options: t = {} }) {
+    let n = this.instances.get(e);
+    if (!n && this.component && (n = this.component.instanceFactory(this.container, {
+      instanceIdentifier: Yt(e),
+      options: t
+    }), this.instances.set(e, n), this.instancesOptions.set(e, t), this.invokeOnInitCallbacks(n, e), this.component.onInstanceCreated))
+      try {
+        this.component.onInstanceCreated(this.container, e, n);
+      } catch {
+      }
+    return n || null;
+  }
+  normalizeInstanceIdentifier(e = y) {
+    return this.component ? this.component.multipleInstances ? e : y : e;
+  }
+  shouldAutoInitialize() {
+    return !!this.component && this.component.instantiationMode !== "EXPLICIT";
+  }
+}
+function Yt(r) {
+  return r === y ? void 0 : r;
+}
+function Qt(r) {
+  return r.instantiationMode === "EAGER";
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Zt {
+  constructor(e) {
+    this.name = e, this.providers = /* @__PURE__ */ new Map();
+  }
+  /**
+   *
+   * @param component Component being added
+   * @param overwrite When a component with the same name has already been registered,
+   * if overwrite is true: overwrite the existing component with the new component and create a new
+   * provider with the new component. It can be useful in tests where you want to use different mocks
+   * for different tests.
+   * if overwrite is false: throw an exception
+   */
+  addComponent(e) {
+    const t = this.getProvider(e.name);
+    if (t.isComponentSet())
+      throw new Error(`Component ${e.name} has already been registered with ${this.name}`);
+    t.setComponent(e);
+  }
+  addOrOverwriteComponent(e) {
+    this.getProvider(e.name).isComponentSet() && this.providers.delete(e.name), this.addComponent(e);
+  }
+  /**
+   * getProvider provides a type safe interface where it can only be called with a field name
+   * present in NameServiceMapping interface.
+   *
+   * Firebase SDKs providing services should extend NameServiceMapping interface to register
+   * themselves.
+   */
+  getProvider(e) {
+    if (this.providers.has(e))
+      return this.providers.get(e);
+    const t = new Xt(e, this);
+    return this.providers.set(e, t), t;
+  }
+  getProviders() {
+    return Array.from(this.providers.values());
+  }
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var d;
+(function(r) {
+  r[r.DEBUG = 0] = "DEBUG", r[r.VERBOSE = 1] = "VERBOSE", r[r.INFO = 2] = "INFO", r[r.WARN = 3] = "WARN", r[r.ERROR = 4] = "ERROR", r[r.SILENT = 5] = "SILENT";
+})(d || (d = {}));
+const er = {
+  debug: d.DEBUG,
+  verbose: d.VERBOSE,
+  info: d.INFO,
+  warn: d.WARN,
+  error: d.ERROR,
+  silent: d.SILENT
+}, tr = d.INFO, rr = {
+  [d.DEBUG]: "log",
+  [d.VERBOSE]: "log",
+  [d.INFO]: "info",
+  [d.WARN]: "warn",
+  [d.ERROR]: "error"
+}, nr = (r, e, ...t) => {
+  if (e < r.logLevel)
+    return;
+  const n = (/* @__PURE__ */ new Date()).toISOString(), i = rr[e];
+  if (i)
+    console[i](`[${n}]  ${r.name}:`, ...t);
+  else
+    throw new Error(`Attempted to log a message with an invalid logType (value: ${e})`);
+};
+class ze {
+  /**
+   * Gives you an instance of a Logger to capture messages according to
+   * Firebase's logging scheme.
+   *
+   * @param name The name that the logs will be associated with
+   */
+  constructor(e) {
+    this.name = e, this._logLevel = tr, this._logHandler = nr, this._userLogHandler = null;
+  }
+  get logLevel() {
+    return this._logLevel;
+  }
+  set logLevel(e) {
+    if (!(e in d))
+      throw new TypeError(`Invalid value "${e}" assigned to \`logLevel\``);
+    this._logLevel = e;
+  }
+  // Workaround for setter/getter having to be the same type.
+  setLogLevel(e) {
+    this._logLevel = typeof e == "string" ? er[e] : e;
+  }
+  get logHandler() {
+    return this._logHandler;
+  }
+  set logHandler(e) {
+    if (typeof e != "function")
+      throw new TypeError("Value assigned to `logHandler` must be a function");
+    this._logHandler = e;
+  }
+  get userLogHandler() {
+    return this._userLogHandler;
+  }
+  set userLogHandler(e) {
+    this._userLogHandler = e;
+  }
+  /**
+   * The functions below are all based on the `console` interface
+   */
+  debug(...e) {
+    this._userLogHandler && this._userLogHandler(this, d.DEBUG, ...e), this._logHandler(this, d.DEBUG, ...e);
+  }
+  log(...e) {
+    this._userLogHandler && this._userLogHandler(this, d.VERBOSE, ...e), this._logHandler(this, d.VERBOSE, ...e);
+  }
+  info(...e) {
+    this._userLogHandler && this._userLogHandler(this, d.INFO, ...e), this._logHandler(this, d.INFO, ...e);
+  }
+  warn(...e) {
+    this._userLogHandler && this._userLogHandler(this, d.WARN, ...e), this._logHandler(this, d.WARN, ...e);
+  }
+  error(...e) {
+    this._userLogHandler && this._userLogHandler(this, d.ERROR, ...e), this._logHandler(this, d.ERROR, ...e);
+  }
+}
+const ir = (r, e) => e.some((t) => r instanceof t);
+let Ie, ye;
+function sr() {
+  return Ie || (Ie = [
+    IDBDatabase,
+    IDBObjectStore,
+    IDBIndex,
+    IDBCursor,
+    IDBTransaction
+  ]);
+}
+function ar() {
+  return ye || (ye = [
+    IDBCursor.prototype.advance,
+    IDBCursor.prototype.continue,
+    IDBCursor.prototype.continuePrimaryKey
+  ]);
+}
+const je = /* @__PURE__ */ new WeakMap(), ne = /* @__PURE__ */ new WeakMap(), We = /* @__PURE__ */ new WeakMap(), X = /* @__PURE__ */ new WeakMap(), he = /* @__PURE__ */ new WeakMap();
+function or(r) {
+  const e = new Promise((t, n) => {
+    const i = () => {
+      r.removeEventListener("success", s), r.removeEventListener("error", a);
+    }, s = () => {
+      t(b(r.result)), i();
+    }, a = () => {
+      n(r.error), i();
+    };
+    r.addEventListener("success", s), r.addEventListener("error", a);
+  });
+  return e.then((t) => {
+    t instanceof IDBCursor && je.set(t, r);
+  }).catch(() => {
+  }), he.set(e, r), e;
+}
+function cr(r) {
+  if (ne.has(r))
+    return;
+  const e = new Promise((t, n) => {
+    const i = () => {
+      r.removeEventListener("complete", s), r.removeEventListener("error", a), r.removeEventListener("abort", a);
+    }, s = () => {
+      t(), i();
+    }, a = () => {
+      n(r.error || new DOMException("AbortError", "AbortError")), i();
+    };
+    r.addEventListener("complete", s), r.addEventListener("error", a), r.addEventListener("abort", a);
+  });
+  ne.set(r, e);
+}
+let ie = {
+  get(r, e, t) {
+    if (r instanceof IDBTransaction) {
+      if (e === "done")
+        return ne.get(r);
+      if (e === "objectStoreNames")
+        return r.objectStoreNames || We.get(r);
+      if (e === "store")
+        return t.objectStoreNames[1] ? void 0 : t.objectStore(t.objectStoreNames[0]);
+    }
+    return b(r[e]);
+  },
+  set(r, e, t) {
+    return r[e] = t, !0;
+  },
+  has(r, e) {
+    return r instanceof IDBTransaction && (e === "done" || e === "store") ? !0 : e in r;
+  }
+};
+function lr(r) {
+  ie = r(ie);
+}
+function hr(r) {
+  return r === IDBDatabase.prototype.transaction && !("objectStoreNames" in IDBTransaction.prototype) ? function(e, ...t) {
+    const n = r.call(Y(this), e, ...t);
+    return We.set(n, e.sort ? e.sort() : [e]), b(n);
+  } : ar().includes(r) ? function(...e) {
+    return r.apply(Y(this), e), b(je.get(this));
+  } : function(...e) {
+    return b(r.apply(Y(this), e));
+  };
+}
+function dr(r) {
+  return typeof r == "function" ? hr(r) : (r instanceof IDBTransaction && cr(r), ir(r, sr()) ? new Proxy(r, ie) : r);
+}
+function b(r) {
+  if (r instanceof IDBRequest)
+    return or(r);
+  if (X.has(r))
+    return X.get(r);
+  const e = dr(r);
+  return e !== r && (X.set(r, e), he.set(e, r)), e;
+}
+const Y = (r) => he.get(r);
+function ur(r, e, { blocked: t, upgrade: n, blocking: i, terminated: s } = {}) {
+  const a = indexedDB.open(r, e), c = b(a);
+  return n && a.addEventListener("upgradeneeded", (o) => {
+    n(b(a.result), o.oldVersion, o.newVersion, b(a.transaction), o);
+  }), t && a.addEventListener("blocked", (o) => t(
+    // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+    o.oldVersion,
+    o.newVersion,
+    o
+  )), c.then((o) => {
+    s && o.addEventListener("close", () => s()), i && o.addEventListener("versionchange", (l) => i(l.oldVersion, l.newVersion, l));
+  }).catch(() => {
+  }), c;
+}
+const fr = ["get", "getKey", "getAll", "getAllKeys", "count"], pr = ["put", "add", "delete", "clear"], Q = /* @__PURE__ */ new Map();
+function Ee(r, e) {
+  if (!(r instanceof IDBDatabase && !(e in r) && typeof e == "string"))
+    return;
+  if (Q.get(e))
+    return Q.get(e);
+  const t = e.replace(/FromIndex$/, ""), n = e !== t, i = pr.includes(t);
+  if (
+    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
+    !(t in (n ? IDBIndex : IDBObjectStore).prototype) || !(i || fr.includes(t))
+  )
+    return;
+  const s = async function(a, ...c) {
+    const o = this.transaction(a, i ? "readwrite" : "readonly");
+    let l = o.store;
+    return n && (l = l.index(c.shift())), (await Promise.all([
+      l[t](...c),
+      i && o.done
+    ]))[0];
+  };
+  return Q.set(e, s), s;
+}
+lr((r) => ({
+  ...r,
+  get: (e, t, n) => Ee(e, t) || r.get(e, t, n),
+  has: (e, t) => !!Ee(e, t) || r.has(e, t)
+}));
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class mr {
+  constructor(e) {
+    this.container = e;
+  }
+  // In initial implementation, this will be called by installations on
+  // auth token refresh, and installations will send this string.
+  getPlatformInfoString() {
+    return this.container.getProviders().map((t) => {
+      if (gr(t)) {
+        const n = t.getImmediate();
+        return `${n.library}/${n.version}`;
+      } else
+        return null;
+    }).filter((t) => t).join(" ");
+  }
+}
+function gr(r) {
+  const e = r.getComponent();
+  return (e == null ? void 0 : e.type) === "VERSION";
+}
+const se = "@firebase/app", we = "0.10.13";
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const m = new ze("@firebase/app"), _r = "@firebase/app-compat", br = "@firebase/analytics-compat", vr = "@firebase/analytics", Ir = "@firebase/app-check-compat", yr = "@firebase/app-check", Er = "@firebase/auth", wr = "@firebase/auth-compat", Sr = "@firebase/database", Ar = "@firebase/data-connect", Tr = "@firebase/database-compat", Cr = "@firebase/functions", Nr = "@firebase/functions-compat", Dr = "@firebase/installations", Or = "@firebase/installations-compat", kr = "@firebase/messaging", Pr = "@firebase/messaging-compat", Rr = "@firebase/performance", Lr = "@firebase/performance-compat", Ur = "@firebase/remote-config", Mr = "@firebase/remote-config-compat", Br = "@firebase/storage", xr = "@firebase/storage-compat", Fr = "@firebase/firestore", $r = "@firebase/vertexai-preview", Vr = "@firebase/firestore-compat", Hr = "firebase", zr = "10.14.1";
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const jr = "[DEFAULT]", Wr = {
+  [se]: "fire-core",
+  [_r]: "fire-core-compat",
+  [vr]: "fire-analytics",
+  [br]: "fire-analytics-compat",
+  [yr]: "fire-app-check",
+  [Ir]: "fire-app-check-compat",
+  [Er]: "fire-auth",
+  [wr]: "fire-auth-compat",
+  [Sr]: "fire-rtdb",
+  [Ar]: "fire-data-connect",
+  [Tr]: "fire-rtdb-compat",
+  [Cr]: "fire-fn",
+  [Nr]: "fire-fn-compat",
+  [Dr]: "fire-iid",
+  [Or]: "fire-iid-compat",
+  [kr]: "fire-fcm",
+  [Pr]: "fire-fcm-compat",
+  [Rr]: "fire-perf",
+  [Lr]: "fire-perf-compat",
+  [Ur]: "fire-rc",
+  [Mr]: "fire-rc-compat",
+  [Br]: "fire-gcs",
+  [xr]: "fire-gcs-compat",
+  [Fr]: "fire-fst",
+  [Vr]: "fire-fst-compat",
+  [$r]: "fire-vertex",
+  "fire-js": "fire-js",
+  [Hr]: "fire-js-all"
+};
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const ae = /* @__PURE__ */ new Map(), Gr = /* @__PURE__ */ new Map(), oe = /* @__PURE__ */ new Map();
+function Se(r, e) {
+  try {
+    r.container.addComponent(e);
+  } catch (t) {
+    m.debug(`Component ${e.name} failed to register with FirebaseApp ${r.name}`, t);
+  }
+}
+function P(r) {
+  const e = r.name;
+  if (oe.has(e))
+    return m.debug(`There were multiple attempts to register component ${e}.`), !1;
+  oe.set(e, r);
+  for (const t of ae.values())
+    Se(t, r);
+  for (const t of Gr.values())
+    Se(t, r);
+  return !0;
+}
+function D(r) {
+  return r.settings !== void 0;
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const Kr = {
+  "no-app": "No Firebase App '{$appName}' has been created - call initializeApp() first",
+  "bad-app-name": "Illegal App name: '{$appName}'",
+  "duplicate-app": "Firebase App named '{$appName}' already exists with different options or config",
+  "app-deleted": "Firebase App named '{$appName}' already deleted",
+  "server-app-deleted": "Firebase Server App has been deleted",
+  "no-options": "Need to provide options, when not being deployed to hosting via source.",
+  "invalid-app-argument": "firebase.{$appName}() takes either no argument or a Firebase App instance.",
+  "invalid-log-argument": "First argument to `onLog` must be null or a function.",
+  "idb-open": "Error thrown when opening IndexedDB. Original error: {$originalErrorMessage}.",
+  "idb-get": "Error thrown when reading from IndexedDB. Original error: {$originalErrorMessage}.",
+  "idb-set": "Error thrown when writing to IndexedDB. Original error: {$originalErrorMessage}.",
+  "idb-delete": "Error thrown when deleting from IndexedDB. Original error: {$originalErrorMessage}.",
+  "finalization-registry-not-supported": "FirebaseServerApp deleteOnDeref field defined but the JS runtime does not support FinalizationRegistry.",
+  "invalid-server-app-environment": "FirebaseServerApp is not for use in browser environments."
+}, w = new L("app", "Firebase", Kr);
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Jr {
+  constructor(e, t, n) {
+    this._isDeleted = !1, this._options = Object.assign({}, e), this._config = Object.assign({}, t), this._name = t.name, this._automaticDataCollectionEnabled = t.automaticDataCollectionEnabled, this._container = n, this.container.addComponent(new N(
+      "app",
+      () => this,
+      "PUBLIC"
+      /* ComponentType.PUBLIC */
+    ));
+  }
+  get automaticDataCollectionEnabled() {
+    return this.checkDestroyed(), this._automaticDataCollectionEnabled;
+  }
+  set automaticDataCollectionEnabled(e) {
+    this.checkDestroyed(), this._automaticDataCollectionEnabled = e;
+  }
+  get name() {
+    return this.checkDestroyed(), this._name;
+  }
+  get options() {
+    return this.checkDestroyed(), this._options;
+  }
+  get config() {
+    return this.checkDestroyed(), this._config;
+  }
+  get container() {
+    return this._container;
+  }
+  get isDeleted() {
+    return this._isDeleted;
+  }
+  set isDeleted(e) {
+    this._isDeleted = e;
+  }
+  /**
+   * This function will throw an Error if the App has already been deleted -
+   * use before performing API actions on the App.
+   */
+  checkDestroyed() {
+    if (this.isDeleted)
+      throw w.create("app-deleted", { appName: this._name });
+  }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const de = zr;
+function qr(r, e = {}) {
+  let t = r;
+  typeof e != "object" && (e = { name: e });
+  const n = Object.assign({ name: jr, automaticDataCollectionEnabled: !1 }, e), i = n.name;
+  if (typeof i != "string" || !i)
+    throw w.create("bad-app-name", {
+      appName: String(i)
+    });
+  if (t || (t = Ut()), !t)
+    throw w.create(
+      "no-options"
+      /* AppError.NO_OPTIONS */
+    );
+  const s = ae.get(i);
+  if (s) {
+    if (re(t, s.options) && re(n, s.config))
+      return s;
+    throw w.create("duplicate-app", { appName: i });
+  }
+  const a = new Zt(i);
+  for (const o of oe.values())
+    a.addComponent(o);
+  const c = new Jr(t, n, a);
+  return ae.set(i, c), c;
+}
+function A(r, e, t) {
+  var n;
+  let i = (n = Wr[r]) !== null && n !== void 0 ? n : r;
+  t && (i += `-${t}`);
+  const s = i.match(/\s|\//), a = e.match(/\s|\//);
+  if (s || a) {
+    const c = [
+      `Unable to register library "${i}" with version "${e}":`
+    ];
+    s && c.push(`library name "${i}" contains illegal characters (whitespace or "/")`), s && a && c.push("and"), a && c.push(`version name "${e}" contains illegal characters (whitespace or "/")`), m.warn(c.join(" "));
+    return;
+  }
+  P(new N(
+    `${i}-version`,
+    () => ({ library: i, version: e }),
+    "VERSION"
+    /* ComponentType.VERSION */
+  ));
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const Xr = "firebase-heartbeat-database", Yr = 1, R = "firebase-heartbeat-store";
+let Z = null;
+function Ge() {
+  return Z || (Z = ur(Xr, Yr, {
+    upgrade: (r, e) => {
+      switch (e) {
+        case 0:
+          try {
+            r.createObjectStore(R);
+          } catch (t) {
+            console.warn(t);
+          }
+      }
+    }
+  }).catch((r) => {
+    throw w.create("idb-open", {
+      originalErrorMessage: r.message
+    });
+  })), Z;
+}
+async function Qr(r) {
+  try {
+    const t = (await Ge()).transaction(R), n = await t.objectStore(R).get(Ke(r));
+    return await t.done, n;
+  } catch (e) {
+    if (e instanceof S)
+      m.warn(e.message);
+    else {
+      const t = w.create("idb-get", {
+        originalErrorMessage: e == null ? void 0 : e.message
+      });
+      m.warn(t.message);
+    }
+  }
+}
+async function Ae(r, e) {
+  try {
+    const n = (await Ge()).transaction(R, "readwrite");
+    await n.objectStore(R).put(e, Ke(r)), await n.done;
+  } catch (t) {
+    if (t instanceof S)
+      m.warn(t.message);
+    else {
+      const n = w.create("idb-set", {
+        originalErrorMessage: t == null ? void 0 : t.message
+      });
+      m.warn(n.message);
+    }
+  }
+}
+function Ke(r) {
+  return `${r.name}!${r.options.appId}`;
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const Zr = 1024, en = 30 * 24 * 60 * 60 * 1e3;
+class tn {
+  constructor(e) {
+    this.container = e, this._heartbeatsCache = null;
+    const t = this.container.getProvider("app").getImmediate();
+    this._storage = new nn(t), this._heartbeatsCachePromise = this._storage.read().then((n) => (this._heartbeatsCache = n, n));
+  }
+  /**
+   * Called to report a heartbeat. The function will generate
+   * a HeartbeatsByUserAgent object, update heartbeatsCache, and persist it
+   * to IndexedDB.
+   * Note that we only store one heartbeat per day. So if a heartbeat for today is
+   * already logged, subsequent calls to this function in the same day will be ignored.
+   */
+  async triggerHeartbeat() {
+    var e, t;
+    try {
+      const i = this.container.getProvider("platform-logger").getImmediate().getPlatformInfoString(), s = Te();
+      return ((e = this._heartbeatsCache) === null || e === void 0 ? void 0 : e.heartbeats) == null && (this._heartbeatsCache = await this._heartbeatsCachePromise, ((t = this._heartbeatsCache) === null || t === void 0 ? void 0 : t.heartbeats) == null) || this._heartbeatsCache.lastSentHeartbeatDate === s || this._heartbeatsCache.heartbeats.some((a) => a.date === s) ? void 0 : (this._heartbeatsCache.heartbeats.push({ date: s, agent: i }), this._heartbeatsCache.heartbeats = this._heartbeatsCache.heartbeats.filter((a) => {
+        const c = new Date(a.date).valueOf();
+        return Date.now() - c <= en;
+      }), this._storage.overwrite(this._heartbeatsCache));
+    } catch (n) {
+      m.warn(n);
+    }
+  }
+  /**
+   * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly.
+   * It also clears all heartbeats from memory as well as in IndexedDB.
+   *
+   * NOTE: Consuming product SDKs should not send the header if this method
+   * returns an empty string.
+   */
+  async getHeartbeatsHeader() {
+    var e;
+    try {
+      if (this._heartbeatsCache === null && await this._heartbeatsCachePromise, ((e = this._heartbeatsCache) === null || e === void 0 ? void 0 : e.heartbeats) == null || this._heartbeatsCache.heartbeats.length === 0)
+        return "";
+      const t = Te(), { heartbeatsToSend: n, unsentEntries: i } = rn(this._heartbeatsCache.heartbeats), s = Fe(JSON.stringify({ version: 2, heartbeats: n }));
+      return this._heartbeatsCache.lastSentHeartbeatDate = t, i.length > 0 ? (this._heartbeatsCache.heartbeats = i, await this._storage.overwrite(this._heartbeatsCache)) : (this._heartbeatsCache.heartbeats = [], this._storage.overwrite(this._heartbeatsCache)), s;
+    } catch (t) {
+      return m.warn(t), "";
+    }
+  }
+}
+function Te() {
+  return (/* @__PURE__ */ new Date()).toISOString().substring(0, 10);
+}
+function rn(r, e = Zr) {
+  const t = [];
+  let n = r.slice();
+  for (const i of r) {
+    const s = t.find((a) => a.agent === i.agent);
+    if (s) {
+      if (s.dates.push(i.date), Ce(t) > e) {
+        s.dates.pop();
+        break;
+      }
+    } else if (t.push({
+      agent: i.agent,
+      dates: [i.date]
+    }), Ce(t) > e) {
+      t.pop();
+      break;
+    }
+    n = n.slice(1);
+  }
+  return {
+    heartbeatsToSend: t,
+    unsentEntries: n
+  };
+}
+class nn {
+  constructor(e) {
+    this.app = e, this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();
+  }
+  async runIndexedDBEnvironmentCheck() {
+    return Ht() ? zt().then(() => !0).catch(() => !1) : !1;
+  }
+  /**
+   * Read all heartbeats.
+   */
+  async read() {
+    if (await this._canUseIndexedDBPromise) {
+      const t = await Qr(this.app);
+      return t != null && t.heartbeats ? t : { heartbeats: [] };
+    } else
+      return { heartbeats: [] };
+  }
+  // overwrite the storage with the provided heartbeats
+  async overwrite(e) {
+    var t;
+    if (await this._canUseIndexedDBPromise) {
+      const i = await this.read();
+      return Ae(this.app, {
+        lastSentHeartbeatDate: (t = e.lastSentHeartbeatDate) !== null && t !== void 0 ? t : i.lastSentHeartbeatDate,
+        heartbeats: e.heartbeats
+      });
+    } else
+      return;
+  }
+  // add heartbeats
+  async add(e) {
+    var t;
+    if (await this._canUseIndexedDBPromise) {
+      const i = await this.read();
+      return Ae(this.app, {
+        lastSentHeartbeatDate: (t = e.lastSentHeartbeatDate) !== null && t !== void 0 ? t : i.lastSentHeartbeatDate,
+        heartbeats: [
+          ...i.heartbeats,
+          ...e.heartbeats
+        ]
+      });
+    } else
+      return;
+  }
+}
+function Ce(r) {
+  return Fe(
+    // heartbeatsCache wrapper properties
+    JSON.stringify({ version: 2, heartbeats: r })
+  ).length;
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function sn(r) {
+  P(new N(
+    "platform-logger",
+    (e) => new mr(e),
+    "PRIVATE"
+    /* ComponentType.PRIVATE */
+  )), P(new N(
+    "heartbeat",
+    (e) => new tn(e),
+    "PRIVATE"
+    /* ComponentType.PRIVATE */
+  )), A(se, we, r), A(se, we, "esm2017"), A("fire-js", "");
+}
+sn("");
+var an = "firebase", on = "10.14.1";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+A(an, on, "app");
+function Je(r, e) {
+  var t = {};
+  for (var n in r) Object.prototype.hasOwnProperty.call(r, n) && e.indexOf(n) < 0 && (t[n] = r[n]);
+  if (r != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var i = 0, n = Object.getOwnPropertySymbols(r); i < n.length; i++)
+      e.indexOf(n[i]) < 0 && Object.prototype.propertyIsEnumerable.call(r, n[i]) && (t[n[i]] = r[n[i]]);
+  return t;
+}
+function qe() {
+  return {
+    "dependent-sdk-initialized-before-auth": "Another Firebase SDK was initialized and is trying to use Auth before Auth is initialized. Please be sure to call `initializeAuth` or `getAuth` before starting any other Firebase SDK."
+  };
+}
+const cn = qe, Xe = new L("auth", "Firebase", qe());
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const $ = new ze("@firebase/auth");
+function ln(r, ...e) {
+  $.logLevel <= d.WARN && $.warn(`Auth (${de}): ${r}`, ...e);
+}
+function x(r, ...e) {
+  $.logLevel <= d.ERROR && $.error(`Auth (${de}): ${r}`, ...e);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function Ne(r, ...e) {
+  throw ue(r, ...e);
+}
+function Ye(r, ...e) {
+  return ue(r, ...e);
+}
+function Qe(r, e, t) {
+  const n = Object.assign(Object.assign({}, cn()), { [e]: t });
+  return new L("auth", "Firebase", n).create(e, {
+    appName: r.name
+  });
+}
+function F(r) {
+  return Qe(r, "operation-not-supported-in-this-environment", "Operations that alter the current user are not supported in conjunction with FirebaseServerApp");
+}
+function ue(r, ...e) {
+  if (typeof r != "string") {
+    const t = e[0], n = [...e.slice(1)];
+    return n[0] && (n[0].appName = r.name), r._errorFactory.create(t, ...n);
+  }
+  return Xe.create(r, ...e);
+}
+function h(r, e, ...t) {
+  if (!r)
+    throw ue(e, ...t);
+}
+function O(r) {
+  const e = "INTERNAL ASSERTION FAILED: " + r;
+  throw x(e), new Error(e);
+}
+function V(r, e) {
+  r || O(e);
+}
+function hn() {
+  return De() === "http:" || De() === "https:";
+}
+function De() {
+  var r;
+  return typeof self < "u" && ((r = self.location) === null || r === void 0 ? void 0 : r.protocol) || null;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function dn() {
+  return typeof navigator < "u" && navigator && "onLine" in navigator && typeof navigator.onLine == "boolean" && // Apply only for traditional web apps and Chrome extensions.
+  // This is especially true for Cordova apps which have unreliable
+  // navigator.onLine behavior unless cordova-plugin-network-information is
+  // installed which overwrites the native navigator.onLine value and
+  // defines navigator.connection.
+  (hn() || $t() || "connection" in navigator) ? navigator.onLine : !0;
+}
+function un() {
+  if (typeof navigator > "u")
+    return null;
+  const r = navigator;
+  return (
+    // Most reliable, but only supported in Chrome/Firefox.
+    r.languages && r.languages[0] || // Supported in most browsers, but returns the language of the browser
+    // UI, not the language set in browser settings.
+    r.language || // Couldn't determine language.
+    null
+  );
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class U {
+  constructor(e, t) {
+    this.shortDelay = e, this.longDelay = t, V(t > e, "Short delay should be less than long delay!"), this.isMobile = xt() || Vt();
+  }
+  get() {
+    return dn() ? this.isMobile ? this.longDelay : this.shortDelay : Math.min(5e3, this.shortDelay);
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function fn(r, e) {
+  V(r.emulator, "Emulator should always be set here");
+  const { url: t } = r.emulator;
+  return e ? `${t}${e.startsWith("/") ? e.slice(1) : e}` : t;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Ze {
+  static initialize(e, t, n) {
+    this.fetchImpl = e, t && (this.headersImpl = t), n && (this.responseImpl = n);
+  }
+  static fetch() {
+    if (this.fetchImpl)
+      return this.fetchImpl;
+    if (typeof self < "u" && "fetch" in self)
+      return self.fetch;
+    if (typeof globalThis < "u" && globalThis.fetch)
+      return globalThis.fetch;
+    if (typeof fetch < "u")
+      return fetch;
+    O("Could not find fetch implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill");
+  }
+  static headers() {
+    if (this.headersImpl)
+      return this.headersImpl;
+    if (typeof self < "u" && "Headers" in self)
+      return self.Headers;
+    if (typeof globalThis < "u" && globalThis.Headers)
+      return globalThis.Headers;
+    if (typeof Headers < "u")
+      return Headers;
+    O("Could not find Headers implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill");
+  }
+  static response() {
+    if (this.responseImpl)
+      return this.responseImpl;
+    if (typeof self < "u" && "Response" in self)
+      return self.Response;
+    if (typeof globalThis < "u" && globalThis.Response)
+      return globalThis.Response;
+    if (typeof Response < "u")
+      return Response;
+    O("Could not find Response implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill");
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const pn = {
+  // Custom token errors.
+  CREDENTIAL_MISMATCH: "custom-token-mismatch",
+  // This can only happen if the SDK sends a bad request.
+  MISSING_CUSTOM_TOKEN: "internal-error",
+  // Create Auth URI errors.
+  INVALID_IDENTIFIER: "invalid-email",
+  // This can only happen if the SDK sends a bad request.
+  MISSING_CONTINUE_URI: "internal-error",
+  // Sign in with email and password errors (some apply to sign up too).
+  INVALID_PASSWORD: "wrong-password",
+  // This can only happen if the SDK sends a bad request.
+  MISSING_PASSWORD: "missing-password",
+  // Thrown if Email Enumeration Protection is enabled in the project and the email or password is
+  // invalid.
+  INVALID_LOGIN_CREDENTIALS: "invalid-credential",
+  // Sign up with email and password errors.
+  EMAIL_EXISTS: "email-already-in-use",
+  PASSWORD_LOGIN_DISABLED: "operation-not-allowed",
+  // Verify assertion for sign in with credential errors:
+  INVALID_IDP_RESPONSE: "invalid-credential",
+  INVALID_PENDING_TOKEN: "invalid-credential",
+  FEDERATED_USER_ID_ALREADY_LINKED: "credential-already-in-use",
+  // This can only happen if the SDK sends a bad request.
+  MISSING_REQ_TYPE: "internal-error",
+  // Send Password reset email errors:
+  EMAIL_NOT_FOUND: "user-not-found",
+  RESET_PASSWORD_EXCEED_LIMIT: "too-many-requests",
+  EXPIRED_OOB_CODE: "expired-action-code",
+  INVALID_OOB_CODE: "invalid-action-code",
+  // This can only happen if the SDK sends a bad request.
+  MISSING_OOB_CODE: "internal-error",
+  // Operations that require ID token in request:
+  CREDENTIAL_TOO_OLD_LOGIN_AGAIN: "requires-recent-login",
+  INVALID_ID_TOKEN: "invalid-user-token",
+  TOKEN_EXPIRED: "user-token-expired",
+  USER_NOT_FOUND: "user-token-expired",
+  // Other errors.
+  TOO_MANY_ATTEMPTS_TRY_LATER: "too-many-requests",
+  PASSWORD_DOES_NOT_MEET_REQUIREMENTS: "password-does-not-meet-requirements",
+  // Phone Auth related errors.
+  INVALID_CODE: "invalid-verification-code",
+  INVALID_SESSION_INFO: "invalid-verification-id",
+  INVALID_TEMPORARY_PROOF: "invalid-credential",
+  MISSING_SESSION_INFO: "missing-verification-id",
+  SESSION_EXPIRED: "code-expired",
+  // Other action code errors when additional settings passed.
+  // MISSING_CONTINUE_URI is getting mapped to INTERNAL_ERROR above.
+  // This is OK as this error will be caught by client side validation.
+  MISSING_ANDROID_PACKAGE_NAME: "missing-android-pkg-name",
+  UNAUTHORIZED_DOMAIN: "unauthorized-continue-uri",
+  // getProjectConfig errors when clientId is passed.
+  INVALID_OAUTH_CLIENT_ID: "invalid-oauth-client-id",
+  // User actions (sign-up or deletion) disabled errors.
+  ADMIN_ONLY_OPERATION: "admin-restricted-operation",
+  // Multi factor related errors.
+  INVALID_MFA_PENDING_CREDENTIAL: "invalid-multi-factor-session",
+  MFA_ENROLLMENT_NOT_FOUND: "multi-factor-info-not-found",
+  MISSING_MFA_ENROLLMENT_ID: "missing-multi-factor-info",
+  MISSING_MFA_PENDING_CREDENTIAL: "missing-multi-factor-session",
+  SECOND_FACTOR_EXISTS: "second-factor-already-in-use",
+  SECOND_FACTOR_LIMIT_EXCEEDED: "maximum-second-factor-count-exceeded",
+  // Blocking functions related errors.
+  BLOCKING_FUNCTION_ERROR_RESPONSE: "internal-error",
+  // Recaptcha related errors.
+  RECAPTCHA_NOT_ENABLED: "recaptcha-not-enabled",
+  MISSING_RECAPTCHA_TOKEN: "missing-recaptcha-token",
+  INVALID_RECAPTCHA_TOKEN: "invalid-recaptcha-token",
+  INVALID_RECAPTCHA_ACTION: "invalid-recaptcha-action",
+  MISSING_CLIENT_TYPE: "missing-client-type",
+  MISSING_RECAPTCHA_VERSION: "missing-recaptcha-version",
+  INVALID_RECAPTCHA_VERSION: "invalid-recaptcha-version",
+  INVALID_REQ_TYPE: "invalid-req-type"
+  /* AuthErrorCode.INVALID_REQ_TYPE */
+};
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const mn = new U(3e4, 6e4);
+function et(r, e) {
+  return r.tenantId && !e.tenantId ? Object.assign(Object.assign({}, e), { tenantId: r.tenantId }) : e;
+}
+async function j(r, e, t, n, i = {}) {
+  return tt(r, i, async () => {
+    let s = {}, a = {};
+    n && (e === "GET" ? a = n : s = {
+      body: JSON.stringify(n)
+    });
+    const c = He(Object.assign({ key: r.config.apiKey }, a)).slice(1), o = await r._getAdditionalHeaders();
+    o[
+      "Content-Type"
+      /* HttpHeader.CONTENT_TYPE */
+    ] = "application/json", r.languageCode && (o[
+      "X-Firebase-Locale"
+      /* HttpHeader.X_FIREBASE_LOCALE */
+    ] = r.languageCode);
+    const l = Object.assign({
+      method: e,
+      headers: o
+    }, s);
+    return Ft() || (l.referrerPolicy = "no-referrer"), Ze.fetch()(rt(r, r.config.apiHost, t, c), l);
+  });
+}
+async function tt(r, e, t) {
+  r._canInitEmulator = !1;
+  const n = Object.assign(Object.assign({}, pn), e);
+  try {
+    const i = new gn(r), s = await Promise.race([
+      t(),
+      i.promise
+    ]);
+    i.clearNetworkTimeout();
+    const a = await s.json();
+    if ("needConfirmation" in a)
+      throw B(r, "account-exists-with-different-credential", a);
+    if (s.ok && !("errorMessage" in a))
+      return a;
+    {
+      const c = s.ok ? a.errorMessage : a.error.message, [o, l] = c.split(" : ");
+      if (o === "FEDERATED_USER_ID_ALREADY_LINKED")
+        throw B(r, "credential-already-in-use", a);
+      if (o === "EMAIL_EXISTS")
+        throw B(r, "email-already-in-use", a);
+      if (o === "USER_DISABLED")
+        throw B(r, "user-disabled", a);
+      const u = n[o] || o.toLowerCase().replace(/[_\s]+/g, "-");
+      if (l)
+        throw Qe(r, u, l);
+      Ne(r, u);
+    }
+  } catch (i) {
+    if (i instanceof S)
+      throw i;
+    Ne(r, "network-request-failed", { message: String(i) });
+  }
+}
+function rt(r, e, t, n) {
+  const i = `${e}${t}?${n}`;
+  return r.config.emulator ? fn(r.config, i) : `${r.config.apiScheme}://${i}`;
+}
+class gn {
+  constructor(e) {
+    this.auth = e, this.timer = null, this.promise = new Promise((t, n) => {
+      this.timer = setTimeout(() => n(Ye(
+        this.auth,
+        "network-request-failed"
+        /* AuthErrorCode.NETWORK_REQUEST_FAILED */
+      )), mn.get());
+    });
+  }
+  clearNetworkTimeout() {
+    clearTimeout(this.timer);
+  }
+}
+function B(r, e, t) {
+  const n = {
+    appName: r.name
+  };
+  t.email && (n.email = t.email), t.phoneNumber && (n.phoneNumber = t.phoneNumber);
+  const i = Ye(r, e, n);
+  return i.customData._tokenResponse = t, i;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function _n(r, e) {
+  return j(r, "POST", "/v1/accounts:delete", e);
+}
+async function nt(r, e) {
+  return j(r, "POST", "/v1/accounts:lookup", e);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function k(r) {
+  if (r)
+    try {
+      const e = new Date(Number(r));
+      if (!isNaN(e.getTime()))
+        return e.toUTCString();
+    } catch {
+    }
+}
+async function bn(r, e = !1) {
+  const t = z(r), n = await t.getIdToken(e), i = it(n);
+  h(
+    i && i.exp && i.auth_time && i.iat,
+    t.auth,
+    "internal-error"
+    /* AuthErrorCode.INTERNAL_ERROR */
+  );
+  const s = typeof i.firebase == "object" ? i.firebase : void 0, a = s == null ? void 0 : s.sign_in_provider;
+  return {
+    claims: i,
+    token: n,
+    authTime: k(ee(i.auth_time)),
+    issuedAtTime: k(ee(i.iat)),
+    expirationTime: k(ee(i.exp)),
+    signInProvider: a || null,
+    signInSecondFactor: (s == null ? void 0 : s.sign_in_second_factor) || null
+  };
+}
+function ee(r) {
+  return Number(r) * 1e3;
+}
+function it(r) {
+  const [e, t, n] = r.split(".");
+  if (e === void 0 || t === void 0 || n === void 0)
+    return x("JWT malformed, contained fewer than 3 sections"), null;
+  try {
+    const i = $e(t);
+    return i ? JSON.parse(i) : (x("Failed to decode base64 JWT payload"), null);
+  } catch (i) {
+    return x("Caught error parsing JWT payload as JSON", i == null ? void 0 : i.toString()), null;
+  }
+}
+function Oe(r) {
+  const e = it(r);
+  return h(
+    e,
+    "internal-error"
+    /* AuthErrorCode.INTERNAL_ERROR */
+  ), h(
+    typeof e.exp < "u",
+    "internal-error"
+    /* AuthErrorCode.INTERNAL_ERROR */
+  ), h(
+    typeof e.iat < "u",
+    "internal-error"
+    /* AuthErrorCode.INTERNAL_ERROR */
+  ), Number(e.exp) - Number(e.iat);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function ce(r, e, t = !1) {
+  if (t)
+    return e;
+  try {
+    return await e;
+  } catch (n) {
+    throw n instanceof S && vn(n) && r.auth.currentUser === r && await r.auth.signOut(), n;
+  }
+}
+function vn({ code: r }) {
+  return r === "auth/user-disabled" || r === "auth/user-token-expired";
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class In {
+  constructor(e) {
+    this.user = e, this.isRunning = !1, this.timerId = null, this.errorBackoff = 3e4;
+  }
+  _start() {
+    this.isRunning || (this.isRunning = !0, this.schedule());
+  }
+  _stop() {
+    this.isRunning && (this.isRunning = !1, this.timerId !== null && clearTimeout(this.timerId));
+  }
+  getInterval(e) {
+    var t;
+    if (e) {
+      const n = this.errorBackoff;
+      return this.errorBackoff = Math.min(
+        this.errorBackoff * 2,
+        96e4
+        /* Duration.RETRY_BACKOFF_MAX */
+      ), n;
+    } else {
+      this.errorBackoff = 3e4;
+      const i = ((t = this.user.stsTokenManager.expirationTime) !== null && t !== void 0 ? t : 0) - Date.now() - 3e5;
+      return Math.max(0, i);
+    }
+  }
+  schedule(e = !1) {
+    if (!this.isRunning)
+      return;
+    const t = this.getInterval(e);
+    this.timerId = setTimeout(async () => {
+      await this.iteration();
+    }, t);
+  }
+  async iteration() {
+    try {
+      await this.user.getIdToken(!0);
+    } catch (e) {
+      (e == null ? void 0 : e.code) === "auth/network-request-failed" && this.schedule(
+        /* wasError */
+        !0
+      );
+      return;
+    }
+    this.schedule();
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class le {
+  constructor(e, t) {
+    this.createdAt = e, this.lastLoginAt = t, this._initializeTime();
+  }
+  _initializeTime() {
+    this.lastSignInTime = k(this.lastLoginAt), this.creationTime = k(this.createdAt);
+  }
+  _copy(e) {
+    this.createdAt = e.createdAt, this.lastLoginAt = e.lastLoginAt, this._initializeTime();
+  }
+  toJSON() {
+    return {
+      createdAt: this.createdAt,
+      lastLoginAt: this.lastLoginAt
+    };
+  }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function H(r) {
+  var e;
+  const t = r.auth, n = await r.getIdToken(), i = await ce(r, nt(t, { idToken: n }));
+  h(
+    i == null ? void 0 : i.users.length,
+    t,
+    "internal-error"
+    /* AuthErrorCode.INTERNAL_ERROR */
+  );
+  const s = i.users[0];
+  r._notifyReloadListener(s);
+  const a = !((e = s.providerUserInfo) === null || e === void 0) && e.length ? st(s.providerUserInfo) : [], c = En(r.providerData, a), o = r.isAnonymous, l = !(r.email && s.passwordHash) && !(c != null && c.length), u = o ? l : !1, f = {
+    uid: s.localId,
+    displayName: s.displayName || null,
+    photoURL: s.photoUrl || null,
+    email: s.email || null,
+    emailVerified: s.emailVerified || !1,
+    phoneNumber: s.phoneNumber || null,
+    tenantId: s.tenantId || null,
+    providerData: c,
+    metadata: new le(s.createdAt, s.lastLoginAt),
+    isAnonymous: u
+  };
+  Object.assign(r, f);
+}
+async function yn(r) {
+  const e = z(r);
+  await H(e), await e.auth._persistUserIfCurrent(e), e.auth._notifyListenersIfCurrent(e);
+}
+function En(r, e) {
+  return [...r.filter((n) => !e.some((i) => i.providerId === n.providerId)), ...e];
+}
+function st(r) {
+  return r.map((e) => {
+    var { providerId: t } = e, n = Je(e, ["providerId"]);
+    return {
+      providerId: t,
+      uid: n.rawId || "",
+      displayName: n.displayName || null,
+      email: n.email || null,
+      phoneNumber: n.phoneNumber || null,
+      photoURL: n.photoUrl || null
+    };
+  });
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function wn(r, e) {
+  const t = await tt(r, {}, async () => {
+    const n = He({
+      grant_type: "refresh_token",
+      refresh_token: e
+    }).slice(1), { tokenApiHost: i, apiKey: s } = r.config, a = rt(r, i, "/v1/token", `key=${s}`), c = await r._getAdditionalHeaders();
+    return c[
+      "Content-Type"
+      /* HttpHeader.CONTENT_TYPE */
+    ] = "application/x-www-form-urlencoded", Ze.fetch()(a, {
+      method: "POST",
+      headers: c,
+      body: n
+    });
+  });
+  return {
+    accessToken: t.access_token,
+    expiresIn: t.expires_in,
+    refreshToken: t.refresh_token
+  };
+}
+async function Sn(r, e) {
+  return j(r, "POST", "/v2/accounts:revokeToken", et(r, e));
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class T {
+  constructor() {
+    this.refreshToken = null, this.accessToken = null, this.expirationTime = null;
+  }
+  get isExpired() {
+    return !this.expirationTime || Date.now() > this.expirationTime - 3e4;
+  }
+  updateFromServerResponse(e) {
+    h(
+      e.idToken,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), h(
+      typeof e.idToken < "u",
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), h(
+      typeof e.refreshToken < "u",
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    );
+    const t = "expiresIn" in e && typeof e.expiresIn < "u" ? Number(e.expiresIn) : Oe(e.idToken);
+    this.updateTokensAndExpiration(e.idToken, e.refreshToken, t);
+  }
+  updateFromIdToken(e) {
+    h(
+      e.length !== 0,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    );
+    const t = Oe(e);
+    this.updateTokensAndExpiration(e, null, t);
+  }
+  async getToken(e, t = !1) {
+    return !t && this.accessToken && !this.isExpired ? this.accessToken : (h(
+      this.refreshToken,
+      e,
+      "user-token-expired"
+      /* AuthErrorCode.TOKEN_EXPIRED */
+    ), this.refreshToken ? (await this.refresh(e, this.refreshToken), this.accessToken) : null);
+  }
+  clearRefreshToken() {
+    this.refreshToken = null;
+  }
+  async refresh(e, t) {
+    const { accessToken: n, refreshToken: i, expiresIn: s } = await wn(e, t);
+    this.updateTokensAndExpiration(n, i, Number(s));
+  }
+  updateTokensAndExpiration(e, t, n) {
+    this.refreshToken = t || null, this.accessToken = e || null, this.expirationTime = Date.now() + n * 1e3;
+  }
+  static fromJSON(e, t) {
+    const { refreshToken: n, accessToken: i, expirationTime: s } = t, a = new T();
+    return n && (h(typeof n == "string", "internal-error", {
+      appName: e
+    }), a.refreshToken = n), i && (h(typeof i == "string", "internal-error", {
+      appName: e
+    }), a.accessToken = i), s && (h(typeof s == "number", "internal-error", {
+      appName: e
+    }), a.expirationTime = s), a;
+  }
+  toJSON() {
+    return {
+      refreshToken: this.refreshToken,
+      accessToken: this.accessToken,
+      expirationTime: this.expirationTime
+    };
+  }
+  _assign(e) {
+    this.accessToken = e.accessToken, this.refreshToken = e.refreshToken, this.expirationTime = e.expirationTime;
+  }
+  _clone() {
+    return Object.assign(new T(), this.toJSON());
+  }
+  _performRefresh() {
+    return O("not implemented");
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function g(r, e) {
+  h(typeof r == "string" || typeof r > "u", "internal-error", { appName: e });
+}
+class _ {
+  constructor(e) {
+    var { uid: t, auth: n, stsTokenManager: i } = e, s = Je(e, ["uid", "auth", "stsTokenManager"]);
+    this.providerId = "firebase", this.proactiveRefresh = new In(this), this.reloadUserInfo = null, this.reloadListener = null, this.uid = t, this.auth = n, this.stsTokenManager = i, this.accessToken = i.accessToken, this.displayName = s.displayName || null, this.email = s.email || null, this.emailVerified = s.emailVerified || !1, this.phoneNumber = s.phoneNumber || null, this.photoURL = s.photoURL || null, this.isAnonymous = s.isAnonymous || !1, this.tenantId = s.tenantId || null, this.providerData = s.providerData ? [...s.providerData] : [], this.metadata = new le(s.createdAt || void 0, s.lastLoginAt || void 0);
+  }
+  async getIdToken(e) {
+    const t = await ce(this, this.stsTokenManager.getToken(this.auth, e));
+    return h(
+      t,
+      this.auth,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), this.accessToken !== t && (this.accessToken = t, await this.auth._persistUserIfCurrent(this), this.auth._notifyListenersIfCurrent(this)), t;
+  }
+  getIdTokenResult(e) {
+    return bn(this, e);
+  }
+  reload() {
+    return yn(this);
+  }
+  _assign(e) {
+    this !== e && (h(
+      this.uid === e.uid,
+      this.auth,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), this.displayName = e.displayName, this.photoURL = e.photoURL, this.email = e.email, this.emailVerified = e.emailVerified, this.phoneNumber = e.phoneNumber, this.isAnonymous = e.isAnonymous, this.tenantId = e.tenantId, this.providerData = e.providerData.map((t) => Object.assign({}, t)), this.metadata._copy(e.metadata), this.stsTokenManager._assign(e.stsTokenManager));
+  }
+  _clone(e) {
+    const t = new _(Object.assign(Object.assign({}, this), { auth: e, stsTokenManager: this.stsTokenManager._clone() }));
+    return t.metadata._copy(this.metadata), t;
+  }
+  _onReload(e) {
+    h(
+      !this.reloadListener,
+      this.auth,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), this.reloadListener = e, this.reloadUserInfo && (this._notifyReloadListener(this.reloadUserInfo), this.reloadUserInfo = null);
+  }
+  _notifyReloadListener(e) {
+    this.reloadListener ? this.reloadListener(e) : this.reloadUserInfo = e;
+  }
+  _startProactiveRefresh() {
+    this.proactiveRefresh._start();
+  }
+  _stopProactiveRefresh() {
+    this.proactiveRefresh._stop();
+  }
+  async _updateTokensIfNecessary(e, t = !1) {
+    let n = !1;
+    e.idToken && e.idToken !== this.stsTokenManager.accessToken && (this.stsTokenManager.updateFromServerResponse(e), n = !0), t && await H(this), await this.auth._persistUserIfCurrent(this), n && this.auth._notifyListenersIfCurrent(this);
+  }
+  async delete() {
+    if (D(this.auth.app))
+      return Promise.reject(F(this.auth));
+    const e = await this.getIdToken();
+    return await ce(this, _n(this.auth, { idToken: e })), this.stsTokenManager.clearRefreshToken(), this.auth.signOut();
+  }
+  toJSON() {
+    return Object.assign(Object.assign({
+      uid: this.uid,
+      email: this.email || void 0,
+      emailVerified: this.emailVerified,
+      displayName: this.displayName || void 0,
+      isAnonymous: this.isAnonymous,
+      photoURL: this.photoURL || void 0,
+      phoneNumber: this.phoneNumber || void 0,
+      tenantId: this.tenantId || void 0,
+      providerData: this.providerData.map((e) => Object.assign({}, e)),
+      stsTokenManager: this.stsTokenManager.toJSON(),
+      // Redirect event ID must be maintained in case there is a pending
+      // redirect event.
+      _redirectEventId: this._redirectEventId
+    }, this.metadata.toJSON()), {
+      // Required for compatibility with the legacy SDK (go/firebase-auth-sdk-persistence-parsing):
+      apiKey: this.auth.config.apiKey,
+      appName: this.auth.name
+    });
+  }
+  get refreshToken() {
+    return this.stsTokenManager.refreshToken || "";
+  }
+  static _fromJSON(e, t) {
+    var n, i, s, a, c, o, l, u;
+    const f = (n = t.displayName) !== null && n !== void 0 ? n : void 0, v = (i = t.email) !== null && i !== void 0 ? i : void 0, I = (s = t.phoneNumber) !== null && s !== void 0 ? s : void 0, M = (a = t.photoURL) !== null && a !== void 0 ? a : void 0, fe = (c = t.tenantId) !== null && c !== void 0 ? c : void 0, W = (o = t._redirectEventId) !== null && o !== void 0 ? o : void 0, pe = (l = t.createdAt) !== null && l !== void 0 ? l : void 0, me = (u = t.lastLoginAt) !== null && u !== void 0 ? u : void 0, { uid: G, emailVerified: ge, isAnonymous: _e, providerData: K, stsTokenManager: be } = t;
+    h(
+      G && be,
+      e,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    );
+    const ct = T.fromJSON(this.name, be);
+    h(
+      typeof G == "string",
+      e,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), g(f, e.name), g(v, e.name), h(
+      typeof ge == "boolean",
+      e,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), h(
+      typeof _e == "boolean",
+      e,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), g(I, e.name), g(M, e.name), g(fe, e.name), g(W, e.name), g(pe, e.name), g(me, e.name);
+    const J = new _({
+      uid: G,
+      auth: e,
+      email: v,
+      emailVerified: ge,
+      displayName: f,
+      isAnonymous: _e,
+      photoURL: M,
+      phoneNumber: I,
+      tenantId: fe,
+      stsTokenManager: ct,
+      createdAt: pe,
+      lastLoginAt: me
+    });
+    return K && Array.isArray(K) && (J.providerData = K.map((lt) => Object.assign({}, lt))), W && (J._redirectEventId = W), J;
+  }
+  /**
+   * Initialize a User from an idToken server response
+   * @param auth
+   * @param idTokenResponse
+   */
+  static async _fromIdTokenResponse(e, t, n = !1) {
+    const i = new T();
+    i.updateFromServerResponse(t);
+    const s = new _({
+      uid: t.localId,
+      auth: e,
+      stsTokenManager: i,
+      isAnonymous: n
+    });
+    return await H(s), s;
+  }
+  /**
+   * Initialize a User from an idToken server response
+   * @param auth
+   * @param idTokenResponse
+   */
+  static async _fromGetAccountInfoResponse(e, t, n) {
+    const i = t.users[0];
+    h(
+      i.localId !== void 0,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    );
+    const s = i.providerUserInfo !== void 0 ? st(i.providerUserInfo) : [], a = !(i.email && i.passwordHash) && !(s != null && s.length), c = new T();
+    c.updateFromIdToken(n);
+    const o = new _({
+      uid: i.localId,
+      auth: e,
+      stsTokenManager: c,
+      isAnonymous: a
+    }), l = {
+      uid: i.localId,
+      displayName: i.displayName || null,
+      photoURL: i.photoUrl || null,
+      email: i.email || null,
+      emailVerified: i.emailVerified || !1,
+      phoneNumber: i.phoneNumber || null,
+      tenantId: i.tenantId || null,
+      providerData: s,
+      metadata: new le(i.createdAt, i.lastLoginAt),
+      isAnonymous: !(i.email && i.passwordHash) && !(s != null && s.length)
+    };
+    return Object.assign(o, l), o;
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const ke = /* @__PURE__ */ new Map();
+function E(r) {
+  V(r instanceof Function, "Expected a class definition");
+  let e = ke.get(r);
+  return e ? (V(e instanceof r, "Instance stored in cache mismatched with class"), e) : (e = new r(), ke.set(r, e), e);
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class at {
+  constructor() {
+    this.type = "NONE", this.storage = {};
+  }
+  async _isAvailable() {
+    return !0;
+  }
+  async _set(e, t) {
+    this.storage[e] = t;
+  }
+  async _get(e) {
+    const t = this.storage[e];
+    return t === void 0 ? null : t;
+  }
+  async _remove(e) {
+    delete this.storage[e];
+  }
+  _addListener(e, t) {
+  }
+  _removeListener(e, t) {
+  }
+}
+at.type = "NONE";
+const Pe = at;
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function te(r, e, t) {
+  return `firebase:${r}:${e}:${t}`;
+}
+class C {
+  constructor(e, t, n) {
+    this.persistence = e, this.auth = t, this.userKey = n;
+    const { config: i, name: s } = this.auth;
+    this.fullUserKey = te(this.userKey, i.apiKey, s), this.fullPersistenceKey = te("persistence", i.apiKey, s), this.boundEventHandler = t._onStorageEvent.bind(t), this.persistence._addListener(this.fullUserKey, this.boundEventHandler);
+  }
+  setCurrentUser(e) {
+    return this.persistence._set(this.fullUserKey, e.toJSON());
+  }
+  async getCurrentUser() {
+    const e = await this.persistence._get(this.fullUserKey);
+    return e ? _._fromJSON(this.auth, e) : null;
+  }
+  removeCurrentUser() {
+    return this.persistence._remove(this.fullUserKey);
+  }
+  savePersistenceForRedirect() {
+    return this.persistence._set(this.fullPersistenceKey, this.persistence.type);
+  }
+  async setPersistence(e) {
+    if (this.persistence === e)
+      return;
+    const t = await this.getCurrentUser();
+    if (await this.removeCurrentUser(), this.persistence = e, t)
+      return this.setCurrentUser(t);
+  }
+  delete() {
+    this.persistence._removeListener(this.fullUserKey, this.boundEventHandler);
+  }
+  static async create(e, t, n = "authUser") {
+    if (!t.length)
+      return new C(E(Pe), e, n);
+    const i = (await Promise.all(t.map(async (l) => {
+      if (await l._isAvailable())
+        return l;
+    }))).filter((l) => l);
+    let s = i[0] || E(Pe);
+    const a = te(n, e.config.apiKey, e.name);
+    let c = null;
+    for (const l of t)
+      try {
+        const u = await l._get(a);
+        if (u) {
+          const f = _._fromJSON(e, u);
+          l !== s && (c = f), s = l;
+          break;
+        }
+      } catch {
+      }
+    const o = i.filter((l) => l._shouldAllowMigration);
+    return !s._shouldAllowMigration || !o.length ? new C(s, e, n) : (s = o[0], c && await s._set(a, c.toJSON()), await Promise.all(t.map(async (l) => {
+      if (l !== s)
+        try {
+          await l._remove(a);
+        } catch {
+        }
+    })), new C(s, e, n));
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function Re(r) {
+  const e = r.toLowerCase();
+  if (e.includes("opera/") || e.includes("opr/") || e.includes("opios/"))
+    return "Opera";
+  if (Nn(e))
+    return "IEMobile";
+  if (e.includes("msie") || e.includes("trident/"))
+    return "IE";
+  if (e.includes("edge/"))
+    return "Edge";
+  if (An(e))
+    return "Firefox";
+  if (e.includes("silk/"))
+    return "Silk";
+  if (On(e))
+    return "Blackberry";
+  if (kn(e))
+    return "Webos";
+  if (Tn(e))
+    return "Safari";
+  if ((e.includes("chrome/") || Cn(e)) && !e.includes("edge/"))
+    return "Chrome";
+  if (Dn(e))
+    return "Android";
+  {
+    const t = /([a-zA-Z\d\.]+)\/[a-zA-Z\d\.]*$/, n = r.match(t);
+    if ((n == null ? void 0 : n.length) === 2)
+      return n[1];
+  }
+  return "Other";
+}
+function An(r = p()) {
+  return /firefox\//i.test(r);
+}
+function Tn(r = p()) {
+  const e = r.toLowerCase();
+  return e.includes("safari/") && !e.includes("chrome/") && !e.includes("crios/") && !e.includes("android");
+}
+function Cn(r = p()) {
+  return /crios\//i.test(r);
+}
+function Nn(r = p()) {
+  return /iemobile/i.test(r);
+}
+function Dn(r = p()) {
+  return /android/i.test(r);
+}
+function On(r = p()) {
+  return /blackberry/i.test(r);
+}
+function kn(r = p()) {
+  return /webos/i.test(r);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function ot(r, e = []) {
+  let t;
+  switch (r) {
+    case "Browser":
+      t = Re(p());
+      break;
+    case "Worker":
+      t = `${Re(p())}-${r}`;
+      break;
+    default:
+      t = r;
+  }
+  const n = e.length ? e.join(",") : "FirebaseCore-web";
+  return `${t}/JsCore/${de}/${n}`;
+}
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Pn {
+  constructor(e) {
+    this.auth = e, this.queue = [];
+  }
+  pushCallback(e, t) {
+    const n = (s) => new Promise((a, c) => {
+      try {
+        const o = e(s);
+        a(o);
+      } catch (o) {
+        c(o);
+      }
+    });
+    n.onAbort = t, this.queue.push(n);
+    const i = this.queue.length - 1;
+    return () => {
+      this.queue[i] = () => Promise.resolve();
+    };
+  }
+  async runMiddleware(e) {
+    if (this.auth.currentUser === e)
+      return;
+    const t = [];
+    try {
+      for (const n of this.queue)
+        await n(e), n.onAbort && t.push(n.onAbort);
+    } catch (n) {
+      t.reverse();
+      for (const i of t)
+        try {
+          i();
+        } catch {
+        }
+      throw this.auth._errorFactory.create("login-blocked", {
+        originalMessage: n == null ? void 0 : n.message
+      });
+    }
+  }
+}
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function Rn(r, e = {}) {
+  return j(r, "GET", "/v2/passwordPolicy", et(r, e));
+}
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const Ln = 6;
+class Un {
+  constructor(e) {
+    var t, n, i, s;
+    const a = e.customStrengthOptions;
+    this.customStrengthOptions = {}, this.customStrengthOptions.minPasswordLength = (t = a.minPasswordLength) !== null && t !== void 0 ? t : Ln, a.maxPasswordLength && (this.customStrengthOptions.maxPasswordLength = a.maxPasswordLength), a.containsLowercaseCharacter !== void 0 && (this.customStrengthOptions.containsLowercaseLetter = a.containsLowercaseCharacter), a.containsUppercaseCharacter !== void 0 && (this.customStrengthOptions.containsUppercaseLetter = a.containsUppercaseCharacter), a.containsNumericCharacter !== void 0 && (this.customStrengthOptions.containsNumericCharacter = a.containsNumericCharacter), a.containsNonAlphanumericCharacter !== void 0 && (this.customStrengthOptions.containsNonAlphanumericCharacter = a.containsNonAlphanumericCharacter), this.enforcementState = e.enforcementState, this.enforcementState === "ENFORCEMENT_STATE_UNSPECIFIED" && (this.enforcementState = "OFF"), this.allowedNonAlphanumericCharacters = (i = (n = e.allowedNonAlphanumericCharacters) === null || n === void 0 ? void 0 : n.join("")) !== null && i !== void 0 ? i : "", this.forceUpgradeOnSignin = (s = e.forceUpgradeOnSignin) !== null && s !== void 0 ? s : !1, this.schemaVersion = e.schemaVersion;
+  }
+  validatePassword(e) {
+    var t, n, i, s, a, c;
+    const o = {
+      isValid: !0,
+      passwordPolicy: this
+    };
+    return this.validatePasswordLengthOptions(e, o), this.validatePasswordCharacterOptions(e, o), o.isValid && (o.isValid = (t = o.meetsMinPasswordLength) !== null && t !== void 0 ? t : !0), o.isValid && (o.isValid = (n = o.meetsMaxPasswordLength) !== null && n !== void 0 ? n : !0), o.isValid && (o.isValid = (i = o.containsLowercaseLetter) !== null && i !== void 0 ? i : !0), o.isValid && (o.isValid = (s = o.containsUppercaseLetter) !== null && s !== void 0 ? s : !0), o.isValid && (o.isValid = (a = o.containsNumericCharacter) !== null && a !== void 0 ? a : !0), o.isValid && (o.isValid = (c = o.containsNonAlphanumericCharacter) !== null && c !== void 0 ? c : !0), o;
+  }
+  /**
+   * Validates that the password meets the length options for the policy.
+   *
+   * @param password Password to validate.
+   * @param status Validation status.
+   */
+  validatePasswordLengthOptions(e, t) {
+    const n = this.customStrengthOptions.minPasswordLength, i = this.customStrengthOptions.maxPasswordLength;
+    n && (t.meetsMinPasswordLength = e.length >= n), i && (t.meetsMaxPasswordLength = e.length <= i);
+  }
+  /**
+   * Validates that the password meets the character options for the policy.
+   *
+   * @param password Password to validate.
+   * @param status Validation status.
+   */
+  validatePasswordCharacterOptions(e, t) {
+    this.updatePasswordCharacterOptionsStatuses(
+      t,
+      /* containsLowercaseCharacter= */
+      !1,
+      /* containsUppercaseCharacter= */
+      !1,
+      /* containsNumericCharacter= */
+      !1,
+      /* containsNonAlphanumericCharacter= */
+      !1
+    );
+    let n;
+    for (let i = 0; i < e.length; i++)
+      n = e.charAt(i), this.updatePasswordCharacterOptionsStatuses(
+        t,
+        /* containsLowercaseCharacter= */
+        n >= "a" && n <= "z",
+        /* containsUppercaseCharacter= */
+        n >= "A" && n <= "Z",
+        /* containsNumericCharacter= */
+        n >= "0" && n <= "9",
+        /* containsNonAlphanumericCharacter= */
+        this.allowedNonAlphanumericCharacters.includes(n)
+      );
+  }
+  /**
+   * Updates the running validation status with the statuses for the character options.
+   * Expected to be called each time a character is processed to update each option status
+   * based on the current character.
+   *
+   * @param status Validation status.
+   * @param containsLowercaseCharacter Whether the character is a lowercase letter.
+   * @param containsUppercaseCharacter Whether the character is an uppercase letter.
+   * @param containsNumericCharacter Whether the character is a numeric character.
+   * @param containsNonAlphanumericCharacter Whether the character is a non-alphanumeric character.
+   */
+  updatePasswordCharacterOptionsStatuses(e, t, n, i, s) {
+    this.customStrengthOptions.containsLowercaseLetter && (e.containsLowercaseLetter || (e.containsLowercaseLetter = t)), this.customStrengthOptions.containsUppercaseLetter && (e.containsUppercaseLetter || (e.containsUppercaseLetter = n)), this.customStrengthOptions.containsNumericCharacter && (e.containsNumericCharacter || (e.containsNumericCharacter = i)), this.customStrengthOptions.containsNonAlphanumericCharacter && (e.containsNonAlphanumericCharacter || (e.containsNonAlphanumericCharacter = s));
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Mn {
+  constructor(e, t, n, i) {
+    this.app = e, this.heartbeatServiceProvider = t, this.appCheckServiceProvider = n, this.config = i, this.currentUser = null, this.emulatorConfig = null, this.operations = Promise.resolve(), this.authStateSubscription = new Le(this), this.idTokenSubscription = new Le(this), this.beforeStateQueue = new Pn(this), this.redirectUser = null, this.isProactiveRefreshEnabled = !1, this.EXPECTED_PASSWORD_POLICY_SCHEMA_VERSION = 1, this._canInitEmulator = !0, this._isInitialized = !1, this._deleted = !1, this._initializationPromise = null, this._popupRedirectResolver = null, this._errorFactory = Xe, this._agentRecaptchaConfig = null, this._tenantRecaptchaConfigs = {}, this._projectPasswordPolicy = null, this._tenantPasswordPolicies = {}, this.lastNotifiedUid = void 0, this.languageCode = null, this.tenantId = null, this.settings = { appVerificationDisabledForTesting: !1 }, this.frameworks = [], this.name = e.name, this.clientVersion = i.sdkClientVersion;
+  }
+  _initializeWithPersistence(e, t) {
+    return t && (this._popupRedirectResolver = E(t)), this._initializationPromise = this.queue(async () => {
+      var n, i;
+      if (!this._deleted && (this.persistenceManager = await C.create(this, e), !this._deleted)) {
+        if (!((n = this._popupRedirectResolver) === null || n === void 0) && n._shouldInitProactively)
+          try {
+            await this._popupRedirectResolver._initialize(this);
+          } catch {
+          }
+        await this.initializeCurrentUser(t), this.lastNotifiedUid = ((i = this.currentUser) === null || i === void 0 ? void 0 : i.uid) || null, !this._deleted && (this._isInitialized = !0);
+      }
+    }), this._initializationPromise;
+  }
+  /**
+   * If the persistence is changed in another window, the user manager will let us know
+   */
+  async _onStorageEvent() {
+    if (this._deleted)
+      return;
+    const e = await this.assertedPersistence.getCurrentUser();
+    if (!(!this.currentUser && !e)) {
+      if (this.currentUser && e && this.currentUser.uid === e.uid) {
+        this._currentUser._assign(e), await this.currentUser.getIdToken();
+        return;
+      }
+      await this._updateCurrentUser(
+        e,
+        /* skipBeforeStateCallbacks */
+        !0
+      );
+    }
+  }
+  async initializeCurrentUserFromIdToken(e) {
+    try {
+      const t = await nt(this, { idToken: e }), n = await _._fromGetAccountInfoResponse(this, t, e);
+      await this.directlySetCurrentUser(n);
+    } catch (t) {
+      console.warn("FirebaseServerApp could not login user with provided authIdToken: ", t), await this.directlySetCurrentUser(null);
+    }
+  }
+  async initializeCurrentUser(e) {
+    var t;
+    if (D(this.app)) {
+      const a = this.app.settings.authIdToken;
+      return a ? new Promise((c) => {
+        setTimeout(() => this.initializeCurrentUserFromIdToken(a).then(c, c));
+      }) : this.directlySetCurrentUser(null);
+    }
+    const n = await this.assertedPersistence.getCurrentUser();
+    let i = n, s = !1;
+    if (e && this.config.authDomain) {
+      await this.getOrInitRedirectPersistenceManager();
+      const a = (t = this.redirectUser) === null || t === void 0 ? void 0 : t._redirectEventId, c = i == null ? void 0 : i._redirectEventId, o = await this.tryRedirectSignIn(e);
+      (!a || a === c) && (o != null && o.user) && (i = o.user, s = !0);
+    }
+    if (!i)
+      return this.directlySetCurrentUser(null);
+    if (!i._redirectEventId) {
+      if (s)
+        try {
+          await this.beforeStateQueue.runMiddleware(i);
+        } catch (a) {
+          i = n, this._popupRedirectResolver._overrideRedirectResult(this, () => Promise.reject(a));
+        }
+      return i ? this.reloadAndSetCurrentUserOrClear(i) : this.directlySetCurrentUser(null);
+    }
+    return h(
+      this._popupRedirectResolver,
+      this,
+      "argument-error"
+      /* AuthErrorCode.ARGUMENT_ERROR */
+    ), await this.getOrInitRedirectPersistenceManager(), this.redirectUser && this.redirectUser._redirectEventId === i._redirectEventId ? this.directlySetCurrentUser(i) : this.reloadAndSetCurrentUserOrClear(i);
+  }
+  async tryRedirectSignIn(e) {
+    let t = null;
+    try {
+      t = await this._popupRedirectResolver._completeRedirectFn(this, e, !0);
+    } catch {
+      await this._setRedirectUser(null);
+    }
+    return t;
+  }
+  async reloadAndSetCurrentUserOrClear(e) {
+    try {
+      await H(e);
+    } catch (t) {
+      if ((t == null ? void 0 : t.code) !== "auth/network-request-failed")
+        return this.directlySetCurrentUser(null);
+    }
+    return this.directlySetCurrentUser(e);
+  }
+  useDeviceLanguage() {
+    this.languageCode = un();
+  }
+  async _delete() {
+    this._deleted = !0;
+  }
+  async updateCurrentUser(e) {
+    if (D(this.app))
+      return Promise.reject(F(this));
+    const t = e ? z(e) : null;
+    return t && h(
+      t.auth.config.apiKey === this.config.apiKey,
+      this,
+      "invalid-user-token"
+      /* AuthErrorCode.INVALID_AUTH */
+    ), this._updateCurrentUser(t && t._clone(this));
+  }
+  async _updateCurrentUser(e, t = !1) {
+    if (!this._deleted)
+      return e && h(
+        this.tenantId === e.tenantId,
+        this,
+        "tenant-id-mismatch"
+        /* AuthErrorCode.TENANT_ID_MISMATCH */
+      ), t || await this.beforeStateQueue.runMiddleware(e), this.queue(async () => {
+        await this.directlySetCurrentUser(e), this.notifyAuthListeners();
+      });
+  }
+  async signOut() {
+    return D(this.app) ? Promise.reject(F(this)) : (await this.beforeStateQueue.runMiddleware(null), (this.redirectPersistenceManager || this._popupRedirectResolver) && await this._setRedirectUser(null), this._updateCurrentUser(
+      null,
+      /* skipBeforeStateCallbacks */
+      !0
+    ));
+  }
+  setPersistence(e) {
+    return D(this.app) ? Promise.reject(F(this)) : this.queue(async () => {
+      await this.assertedPersistence.setPersistence(E(e));
+    });
+  }
+  _getRecaptchaConfig() {
+    return this.tenantId == null ? this._agentRecaptchaConfig : this._tenantRecaptchaConfigs[this.tenantId];
+  }
+  async validatePassword(e) {
+    this._getPasswordPolicyInternal() || await this._updatePasswordPolicy();
+    const t = this._getPasswordPolicyInternal();
+    return t.schemaVersion !== this.EXPECTED_PASSWORD_POLICY_SCHEMA_VERSION ? Promise.reject(this._errorFactory.create("unsupported-password-policy-schema-version", {})) : t.validatePassword(e);
+  }
+  _getPasswordPolicyInternal() {
+    return this.tenantId === null ? this._projectPasswordPolicy : this._tenantPasswordPolicies[this.tenantId];
+  }
+  async _updatePasswordPolicy() {
+    const e = await Rn(this), t = new Un(e);
+    this.tenantId === null ? this._projectPasswordPolicy = t : this._tenantPasswordPolicies[this.tenantId] = t;
+  }
+  _getPersistence() {
+    return this.assertedPersistence.persistence.type;
+  }
+  _updateErrorMap(e) {
+    this._errorFactory = new L("auth", "Firebase", e());
+  }
+  onAuthStateChanged(e, t, n) {
+    return this.registerStateListener(this.authStateSubscription, e, t, n);
+  }
+  beforeAuthStateChanged(e, t) {
+    return this.beforeStateQueue.pushCallback(e, t);
+  }
+  onIdTokenChanged(e, t, n) {
+    return this.registerStateListener(this.idTokenSubscription, e, t, n);
+  }
+  authStateReady() {
+    return new Promise((e, t) => {
+      if (this.currentUser)
+        e();
+      else {
+        const n = this.onAuthStateChanged(() => {
+          n(), e();
+        }, t);
+      }
+    });
+  }
+  /**
+   * Revokes the given access token. Currently only supports Apple OAuth access tokens.
+   */
+  async revokeAccessToken(e) {
+    if (this.currentUser) {
+      const t = await this.currentUser.getIdToken(), n = {
+        providerId: "apple.com",
+        tokenType: "ACCESS_TOKEN",
+        token: e,
+        idToken: t
+      };
+      this.tenantId != null && (n.tenantId = this.tenantId), await Sn(this, n);
+    }
+  }
+  toJSON() {
+    var e;
+    return {
+      apiKey: this.config.apiKey,
+      authDomain: this.config.authDomain,
+      appName: this.name,
+      currentUser: (e = this._currentUser) === null || e === void 0 ? void 0 : e.toJSON()
+    };
+  }
+  async _setRedirectUser(e, t) {
+    const n = await this.getOrInitRedirectPersistenceManager(t);
+    return e === null ? n.removeCurrentUser() : n.setCurrentUser(e);
+  }
+  async getOrInitRedirectPersistenceManager(e) {
+    if (!this.redirectPersistenceManager) {
+      const t = e && E(e) || this._popupRedirectResolver;
+      h(
+        t,
+        this,
+        "argument-error"
+        /* AuthErrorCode.ARGUMENT_ERROR */
+      ), this.redirectPersistenceManager = await C.create(
+        this,
+        [E(t._redirectPersistence)],
+        "redirectUser"
+        /* KeyName.REDIRECT_USER */
+      ), this.redirectUser = await this.redirectPersistenceManager.getCurrentUser();
+    }
+    return this.redirectPersistenceManager;
+  }
+  async _redirectUserForId(e) {
+    var t, n;
+    return this._isInitialized && await this.queue(async () => {
+    }), ((t = this._currentUser) === null || t === void 0 ? void 0 : t._redirectEventId) === e ? this._currentUser : ((n = this.redirectUser) === null || n === void 0 ? void 0 : n._redirectEventId) === e ? this.redirectUser : null;
+  }
+  async _persistUserIfCurrent(e) {
+    if (e === this.currentUser)
+      return this.queue(async () => this.directlySetCurrentUser(e));
+  }
+  /** Notifies listeners only if the user is current */
+  _notifyListenersIfCurrent(e) {
+    e === this.currentUser && this.notifyAuthListeners();
+  }
+  _key() {
+    return `${this.config.authDomain}:${this.config.apiKey}:${this.name}`;
+  }
+  _startProactiveRefresh() {
+    this.isProactiveRefreshEnabled = !0, this.currentUser && this._currentUser._startProactiveRefresh();
+  }
+  _stopProactiveRefresh() {
+    this.isProactiveRefreshEnabled = !1, this.currentUser && this._currentUser._stopProactiveRefresh();
+  }
+  /** Returns the current user cast as the internal type */
+  get _currentUser() {
+    return this.currentUser;
+  }
+  notifyAuthListeners() {
+    var e, t;
+    if (!this._isInitialized)
+      return;
+    this.idTokenSubscription.next(this.currentUser);
+    const n = (t = (e = this.currentUser) === null || e === void 0 ? void 0 : e.uid) !== null && t !== void 0 ? t : null;
+    this.lastNotifiedUid !== n && (this.lastNotifiedUid = n, this.authStateSubscription.next(this.currentUser));
+  }
+  registerStateListener(e, t, n, i) {
+    if (this._deleted)
+      return () => {
+      };
+    const s = typeof t == "function" ? t : t.next.bind(t);
+    let a = !1;
+    const c = this._isInitialized ? Promise.resolve() : this._initializationPromise;
+    if (h(
+      c,
+      this,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), c.then(() => {
+      a || s(this.currentUser);
+    }), typeof t == "function") {
+      const o = e.addObserver(t, n, i);
+      return () => {
+        a = !0, o();
+      };
+    } else {
+      const o = e.addObserver(t);
+      return () => {
+        a = !0, o();
+      };
+    }
+  }
+  /**
+   * Unprotected (from race conditions) method to set the current user. This
+   * should only be called from within a queued callback. This is necessary
+   * because the queue shouldn't rely on another queued callback.
+   */
+  async directlySetCurrentUser(e) {
+    this.currentUser && this.currentUser !== e && this._currentUser._stopProactiveRefresh(), e && this.isProactiveRefreshEnabled && e._startProactiveRefresh(), this.currentUser = e, e ? await this.assertedPersistence.setCurrentUser(e) : await this.assertedPersistence.removeCurrentUser();
+  }
+  queue(e) {
+    return this.operations = this.operations.then(e, e), this.operations;
+  }
+  get assertedPersistence() {
+    return h(
+      this.persistenceManager,
+      this,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), this.persistenceManager;
+  }
+  _logFramework(e) {
+    !e || this.frameworks.includes(e) || (this.frameworks.push(e), this.frameworks.sort(), this.clientVersion = ot(this.config.clientPlatform, this._getFrameworks()));
+  }
+  _getFrameworks() {
+    return this.frameworks;
+  }
+  async _getAdditionalHeaders() {
+    var e;
+    const t = {
+      "X-Client-Version": this.clientVersion
+    };
+    this.app.options.appId && (t[
+      "X-Firebase-gmpid"
+      /* HttpHeader.X_FIREBASE_GMPID */
+    ] = this.app.options.appId);
+    const n = await ((e = this.heartbeatServiceProvider.getImmediate({
+      optional: !0
+    })) === null || e === void 0 ? void 0 : e.getHeartbeatsHeader());
+    n && (t[
+      "X-Firebase-Client"
+      /* HttpHeader.X_FIREBASE_CLIENT */
+    ] = n);
+    const i = await this._getAppCheckToken();
+    return i && (t[
+      "X-Firebase-AppCheck"
+      /* HttpHeader.X_FIREBASE_APP_CHECK */
+    ] = i), t;
+  }
+  async _getAppCheckToken() {
+    var e;
+    const t = await ((e = this.appCheckServiceProvider.getImmediate({ optional: !0 })) === null || e === void 0 ? void 0 : e.getToken());
+    return t != null && t.error && ln(`Error while retrieving App Check token: ${t.error}`), t == null ? void 0 : t.token;
+  }
+}
+function Bn(r) {
+  return z(r);
+}
+class Le {
+  constructor(e) {
+    this.auth = e, this.observer = null, this.addObserver = Kt((t) => this.observer = t);
+  }
+  get next() {
+    return h(
+      this.observer,
+      this.auth,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), this.observer.next.bind(this.observer);
+  }
+}
+function xn(r, e) {
+  const t = (e == null ? void 0 : e.persistence) || [], n = (Array.isArray(t) ? t : [t]).map(E);
+  e != null && e.errorMap && r._updateErrorMap(e.errorMap), r._initializeWithPersistence(n, e == null ? void 0 : e.popupRedirectResolver);
+}
+new U(3e4, 6e4);
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+new U(2e3, 1e4);
+/**
+ * @license
+ * Copyright 2020 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+new U(3e4, 6e4);
+/**
+ * @license
+ * Copyright 2020 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+new U(5e3, 15e3);
+var Ue = "@firebase/auth", Me = "1.7.9";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Fn {
+  constructor(e) {
+    this.auth = e, this.internalListeners = /* @__PURE__ */ new Map();
+  }
+  getUid() {
+    var e;
+    return this.assertAuthConfigured(), ((e = this.auth.currentUser) === null || e === void 0 ? void 0 : e.uid) || null;
+  }
+  async getToken(e) {
+    return this.assertAuthConfigured(), await this.auth._initializationPromise, this.auth.currentUser ? { accessToken: await this.auth.currentUser.getIdToken(e) } : null;
+  }
+  addAuthTokenListener(e) {
+    if (this.assertAuthConfigured(), this.internalListeners.has(e))
+      return;
+    const t = this.auth.onIdTokenChanged((n) => {
+      e((n == null ? void 0 : n.stsTokenManager.accessToken) || null);
+    });
+    this.internalListeners.set(e, t), this.updateProactiveRefresh();
+  }
+  removeAuthTokenListener(e) {
+    this.assertAuthConfigured();
+    const t = this.internalListeners.get(e);
+    t && (this.internalListeners.delete(e), t(), this.updateProactiveRefresh());
+  }
+  assertAuthConfigured() {
+    h(
+      this.auth._initializationPromise,
+      "dependent-sdk-initialized-before-auth"
+      /* AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH */
+    );
+  }
+  updateProactiveRefresh() {
+    this.internalListeners.size > 0 ? this.auth._startProactiveRefresh() : this.auth._stopProactiveRefresh();
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function $n(r) {
+  switch (r) {
+    case "Node":
+      return "node";
+    case "ReactNative":
+      return "rn";
+    case "Worker":
+      return "webworker";
+    case "Cordova":
+      return "cordova";
+    case "WebExtension":
+      return "web-extension";
+    default:
+      return;
+  }
+}
+function Vn(r) {
+  P(new N(
+    "auth",
+    (e, { options: t }) => {
+      const n = e.getProvider("app").getImmediate(), i = e.getProvider("heartbeat"), s = e.getProvider("app-check-internal"), { apiKey: a, authDomain: c } = n.options;
+      h(a && !a.includes(":"), "invalid-api-key", { appName: n.name });
+      const o = {
+        apiKey: a,
+        authDomain: c,
+        clientPlatform: r,
+        apiHost: "identitytoolkit.googleapis.com",
+        tokenApiHost: "securetoken.googleapis.com",
+        apiScheme: "https",
+        sdkClientVersion: ot(r)
+      }, l = new Mn(n, i, s, o);
+      return xn(l, t), l;
+    },
+    "PUBLIC"
+    /* ComponentType.PUBLIC */
+  ).setInstantiationMode(
+    "EXPLICIT"
+    /* InstantiationMode.EXPLICIT */
+  ).setInstanceCreatedCallback((e, t, n) => {
+    e.getProvider(
+      "auth-internal"
+      /* _ComponentName.AUTH_INTERNAL */
+    ).initialize();
+  })), P(new N(
+    "auth-internal",
+    (e) => {
+      const t = Bn(e.getProvider(
+        "auth"
+        /* _ComponentName.AUTH */
+      ).getImmediate());
+      return ((n) => new Fn(n))(t);
+    },
+    "PRIVATE"
+    /* ComponentType.PRIVATE */
+  ).setInstantiationMode(
+    "EXPLICIT"
+    /* InstantiationMode.EXPLICIT */
+  )), A(Ue, Me, $n(r)), A(Ue, Me, "esm2017");
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const Hn = 5 * 60;
+Mt("authIdTokenMaxAge");
+Vn(
+  "Browser"
+  /* ClientPlatform.BROWSER */
+);
+var zn = { authClientId: "1a362d621873497b277ea55258cc82594ba148d235257f7bd44ea2acc132d8a4", firebase: { apiKey: "AIzaSyAj8JdCHtP0Vc5vZobCfgoLzWxPIn0WUG4", authDomain: "feedme-dev-4c3ef.firebaseapp.com", databaseURL: "https://feedme-dev-4c3ef.firebaseio.com", projectId: "feedme-dev-4c3ef", storageBucket: "feedme-dev-4c3ef.appspot.com", messagingSenderId: "458797803788", appId: "1:458797803788:web:37f2af2926a84288f0c129", measurementId: "G-J2QG09D2Q7" } };
+const Jn = /* @__PURE__ */ pt({
+  __name: "App",
+  setup(r) {
+    yt();
+    const { state: e } = Ct(), t = ut();
+    return qr(zn.firebase), mt(() => {
+      e.isIframe && parent.postMessage({ event: "ready" }, "*");
+    }), (n, i) => {
+      const s = gt("RouterView");
+      return _t(), bt(s, {
+        key: vt(t).path
+      });
+    };
+  }
+}), qn = {
+  "en-US": wt,
+  "zh-CN": At
+}, Xn = Tt;
+export {
+  Jn as FmApp,
+  qn as i18nMessages,
+  Xn as routers
+};