@ethora/chat-component 26.7.4 → 26.7.6

package/dist/index.esm2017-CL0mvq6y.js

@@ -0,0 +1,1578 @@
+const _e = () => {
+};
+const se = function(t) {
+  const e = [];
+  let n = 0;
+  for (let r = 0; r < t.length; r++) {
+    let s = t.charCodeAt(r);
+    s < 128 ? e[n++] = s : s < 2048 ? (e[n++] = s >> 6 | 192, e[n++] = s & 63 | 128) : (s & 64512) === 55296 && r + 1 < t.length && (t.charCodeAt(r + 1) & 64512) === 56320 ? (s = 65536 + ((s & 1023) << 10) + (t.charCodeAt(++r) & 1023), e[n++] = s >> 18 | 240, e[n++] = s >> 12 & 63 | 128, e[n++] = s >> 6 & 63 | 128, e[n++] = s & 63 | 128) : (e[n++] = s >> 12 | 224, e[n++] = s >> 6 & 63 | 128, e[n++] = s & 63 | 128);
+  }
+  return e;
+}, Ee = function(t) {
+  const e = [];
+  let n = 0, r = 0;
+  for (; n < t.length; ) {
+    const s = t[n++];
+    if (s < 128)
+      e[r++] = String.fromCharCode(s);
+    else if (s > 191 && s < 224) {
+      const i = t[n++];
+      e[r++] = String.fromCharCode((s & 31) << 6 | i & 63);
+    } else if (s > 239 && s < 365) {
+      const i = t[n++], o = t[n++], l = t[n++], c = ((s & 7) << 18 | (i & 63) << 12 | (o & 63) << 6 | l & 63) - 65536;
+      e[r++] = String.fromCharCode(55296 + (c >> 10)), e[r++] = String.fromCharCode(56320 + (c & 1023));
+    } else {
+      const i = t[n++], o = t[n++];
+      e[r++] = String.fromCharCode((s & 15) << 12 | (i & 63) << 6 | o & 63);
+    }
+  }
+  return e.join("");
+}, ie = {
+  /**
+   * 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(t, e) {
+    if (!Array.isArray(t))
+      throw Error("encodeByteArray takes an array as a parameter");
+    this.init_();
+    const n = e ? this.byteToCharMapWebSafe_ : this.byteToCharMap_, r = [];
+    for (let s = 0; s < t.length; s += 3) {
+      const i = t[s], o = s + 1 < t.length, l = o ? t[s + 1] : 0, c = s + 2 < t.length, h = c ? t[s + 2] : 0, v = i >> 2, p = (i & 3) << 4 | l >> 4;
+      let a = (l & 15) << 2 | h >> 6, f = h & 63;
+      c || (f = 64, o || (a = 64)), r.push(n[v], n[p], n[a], n[f]);
+    }
+    return r.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(t, e) {
+    return this.HAS_NATIVE_SUPPORT && !e ? btoa(t) : this.encodeByteArray(se(t), 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(t, e) {
+    return this.HAS_NATIVE_SUPPORT && !e ? atob(t) : Ee(this.decodeStringToByteArray(t, 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(t, e) {
+    this.init_();
+    const n = e ? this.charToByteMapWebSafe_ : this.charToByteMap_, r = [];
+    for (let s = 0; s < t.length; ) {
+      const i = n[t.charAt(s++)], l = s < t.length ? n[t.charAt(s)] : 0;
+      ++s;
+      const h = s < t.length ? n[t.charAt(s)] : 64;
+      ++s;
+      const p = s < t.length ? n[t.charAt(s)] : 64;
+      if (++s, i == null || l == null || h == null || p == null)
+        throw new Ce();
+      const a = i << 2 | l >> 4;
+      if (r.push(a), h !== 64) {
+        const f = l << 4 & 240 | h >> 2;
+        if (r.push(f), p !== 64) {
+          const _ = h << 6 & 192 | p;
+          r.push(_);
+        }
+      }
+    }
+    return r;
+  },
+  /**
+   * 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 t = 0; t < this.ENCODED_VALS.length; t++)
+        this.byteToCharMap_[t] = this.ENCODED_VALS.charAt(t), this.charToByteMap_[this.byteToCharMap_[t]] = t, this.byteToCharMapWebSafe_[t] = this.ENCODED_VALS_WEBSAFE.charAt(t), this.charToByteMapWebSafe_[this.byteToCharMapWebSafe_[t]] = t, t >= this.ENCODED_VALS_BASE.length && (this.charToByteMap_[this.ENCODED_VALS_WEBSAFE.charAt(t)] = t, this.charToByteMapWebSafe_[this.ENCODED_VALS.charAt(t)] = t);
+    }
+  }
+};
+class Ce extends Error {
+  constructor() {
+    super(...arguments), this.name = "DecodeBase64StringError";
+  }
+}
+const we = function(t) {
+  const e = se(t);
+  return ie.encodeByteArray(e, !0);
+}, oe = function(t) {
+  return we(t).replace(/\./g, "");
+}, ae = function(t) {
+  try {
+    return ie.decodeString(t, !0);
+  } catch (e) {
+    console.error("base64Decode failed: ", e);
+  }
+  return null;
+};
+function De() {
+  if (typeof self < "u")
+    return self;
+  if (typeof window < "u" || typeof window < "u")
+    return window;
+  throw new Error("Unable to locate global object.");
+}
+const Ie = () => De().__FIREBASE_DEFAULTS__, Se = () => {
+  if (typeof process > "u" || typeof process.env > "u")
+    return;
+  const t = process.env.__FIREBASE_DEFAULTS__;
+  if (t)
+    return JSON.parse(t);
+}, Ae = () => {
+  if (typeof document > "u")
+    return;
+  let t;
+  try {
+    t = document.cookie.match(/__FIREBASE_DEFAULTS__=([^;]+)/);
+  } catch {
+    return;
+  }
+  const e = t && ae(t[1]);
+  return e && JSON.parse(e);
+}, j = () => {
+  try {
+    return _e() || Ie() || Se() || Ae();
+  } catch (t) {
+    console.info(`Unable to get __FIREBASE_DEFAULTS__ due to: ${t}`);
+    return;
+  }
+}, Xt = (t) => {
+  var e, n;
+  return (n = (e = j()) === null || e === void 0 ? void 0 : e.emulatorHosts) === null || n === void 0 ? void 0 : n[t];
+}, ce = () => {
+  var t;
+  return (t = j()) === null || t === void 0 ? void 0 : t.config;
+}, Qt = (t) => {
+  var e;
+  return (e = j()) === null || e === void 0 ? void 0 : e[`_${t}`];
+};
+class Be {
+  constructor() {
+    this.reject = () => {
+    }, this.resolve = () => {
+    }, this.promise = new Promise((e, n) => {
+      this.resolve = e, this.reject = n;
+    });
+  }
+  /**
+   * 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 (n, r) => {
+      n ? this.reject(n) : this.resolve(r), typeof e == "function" && (this.promise.catch(() => {
+      }), e.length === 1 ? e(n) : e(n, r));
+    };
+  }
+}
+function Oe(t) {
+  return t.endsWith(".cloudworkstations.dev");
+}
+async function en(t) {
+  return (await fetch(t, {
+    credentials: "include"
+  })).ok;
+}
+const E = {};
+function Te() {
+  const t = {
+    prod: [],
+    emulator: []
+  };
+  for (const e of Object.keys(E))
+    E[e] ? t.emulator.push(e) : t.prod.push(e);
+  return t;
+}
+function Me(t) {
+  let e = document.getElementById(t), n = !1;
+  return e || (e = document.createElement("div"), e.setAttribute("id", t), n = !0), { created: n, element: e };
+}
+let K = !1;
+function tn(t, e) {
+  if (typeof window > "u" || typeof document > "u" || !Oe(window.location.host) || E[t] === e || E[t] || // If already set to use emulator, can't go back to prod.
+  K)
+    return;
+  E[t] = e;
+  function n(a) {
+    return `__firebase__banner__${a}`;
+  }
+  const r = "__firebase__banner", i = Te().prod.length > 0;
+  function o() {
+    const a = document.getElementById(r);
+    a && a.remove();
+  }
+  function l(a) {
+    a.style.display = "flex", a.style.background = "#7faaf0", a.style.position = "fixed", a.style.bottom = "5px", a.style.left = "5px", a.style.padding = ".5em", a.style.borderRadius = "5px", a.style.alignItems = "center";
+  }
+  function c(a, f) {
+    a.setAttribute("width", "24"), a.setAttribute("id", f), a.setAttribute("height", "24"), a.setAttribute("viewBox", "0 0 24 24"), a.setAttribute("fill", "none"), a.style.marginLeft = "-6px";
+  }
+  function h() {
+    const a = document.createElement("span");
+    return a.style.cursor = "pointer", a.style.marginLeft = "16px", a.style.fontSize = "24px", a.innerHTML = " &times;", a.onclick = () => {
+      K = !0, o();
+    }, a;
+  }
+  function v(a, f) {
+    a.setAttribute("id", f), a.innerText = "Learn more", a.href = "https://firebase.google.com/docs/studio/preview-apps#preview-backend", a.setAttribute("target", "__blank"), a.style.paddingLeft = "5px", a.style.textDecoration = "underline";
+  }
+  function p() {
+    const a = Me(r), f = n("text"), _ = document.getElementById(f) || document.createElement("span"), W = n("learnmore"), G = document.getElementById(W) || document.createElement("a"), J = n("preprendIcon"), S = document.getElementById(J) || document.createElementNS("http://www.w3.org/2000/svg", "svg");
+    if (a.created) {
+      const M = a.element;
+      l(M), v(G, W);
+      const ve = h();
+      c(S, J), M.append(S, _, G, ve), document.body.appendChild(M);
+    }
+    i ? (_.innerText = "Preview backend disconnected.", S.innerHTML = `<g clip-path="url(#clip0_6013_33858)">
+<path d="M4.8 17.6L12 5.6L19.2 17.6H4.8ZM6.91667 16.4H17.0833L12 7.93333L6.91667 16.4ZM12 15.6C12.1667 15.6 12.3056 15.5444 12.4167 15.4333C12.5389 15.3111 12.6 15.1667 12.6 15C12.6 14.8333 12.5389 14.6944 12.4167 14.5833C12.3056 14.4611 12.1667 14.4 12 14.4C11.8333 14.4 11.6889 14.4611 11.5667 14.5833C11.4556 14.6944 11.4 14.8333 11.4 15C11.4 15.1667 11.4556 15.3111 11.5667 15.4333C11.6889 15.5444 11.8333 15.6 12 15.6ZM11.4 13.6H12.6V10.4H11.4V13.6Z" fill="#212121"/>
+</g>
+<defs>
+<clipPath id="clip0_6013_33858">
+<rect width="24" height="24" fill="white"/>
+</clipPath>
+</defs>`) : (S.innerHTML = `<g clip-path="url(#clip0_6083_34804)">
+<path d="M11.4 15.2H12.6V11.2H11.4V15.2ZM12 10C12.1667 10 12.3056 9.94444 12.4167 9.83333C12.5389 9.71111 12.6 9.56667 12.6 9.4C12.6 9.23333 12.5389 9.09444 12.4167 8.98333C12.3056 8.86111 12.1667 8.8 12 8.8C11.8333 8.8 11.6889 8.86111 11.5667 8.98333C11.4556 9.09444 11.4 9.23333 11.4 9.4C11.4 9.56667 11.4556 9.71111 11.5667 9.83333C11.6889 9.94444 11.8333 10 12 10ZM12 18.4C11.1222 18.4 10.2944 18.2333 9.51667 17.9C8.73889 17.5667 8.05556 17.1111 7.46667 16.5333C6.88889 15.9444 6.43333 15.2611 6.1 14.4833C5.76667 13.7056 5.6 12.8778 5.6 12C5.6 11.1111 5.76667 10.2833 6.1 9.51667C6.43333 8.73889 6.88889 8.06111 7.46667 7.48333C8.05556 6.89444 8.73889 6.43333 9.51667 6.1C10.2944 5.76667 11.1222 5.6 12 5.6C12.8889 5.6 13.7167 5.76667 14.4833 6.1C15.2611 6.43333 15.9389 6.89444 16.5167 7.48333C17.1056 8.06111 17.5667 8.73889 17.9 9.51667C18.2333 10.2833 18.4 11.1111 18.4 12C18.4 12.8778 18.2333 13.7056 17.9 14.4833C17.5667 15.2611 17.1056 15.9444 16.5167 16.5333C15.9389 17.1111 15.2611 17.5667 14.4833 17.9C13.7167 18.2333 12.8889 18.4 12 18.4ZM12 17.2C13.4444 17.2 14.6722 16.6944 15.6833 15.6833C16.6944 14.6722 17.2 13.4444 17.2 12C17.2 10.5556 16.6944 9.32778 15.6833 8.31667C14.6722 7.30555 13.4444 6.8 12 6.8C10.5556 6.8 9.32778 7.30555 8.31667 8.31667C7.30556 9.32778 6.8 10.5556 6.8 12C6.8 13.4444 7.30556 14.6722 8.31667 15.6833C9.32778 16.6944 10.5556 17.2 12 17.2Z" fill="#212121"/>
+</g>
+<defs>
+<clipPath id="clip0_6083_34804">
+<rect width="24" height="24" fill="white"/>
+</clipPath>
+</defs>`, _.innerText = "Preview backend running in this workspace."), _.setAttribute("id", f);
+  }
+  document.readyState === "loading" ? window.addEventListener("DOMContentLoaded", p) : p();
+}
+function le() {
+  return typeof navigator < "u" && typeof navigator.userAgent == "string" ? navigator.userAgent : "";
+}
+function nn() {
+  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(le());
+}
+function Re() {
+  return typeof window < "u" || de();
+}
+function de() {
+  return typeof WorkerGlobalScope < "u" && typeof self < "u" && self instanceof WorkerGlobalScope;
+}
+function rn() {
+  return typeof navigator < "u" && navigator.userAgent === "Cloudflare-Workers";
+}
+function sn() {
+  const t = typeof chrome == "object" ? chrome.runtime : typeof browser == "object" ? browser.runtime : void 0;
+  return typeof t == "object" && t.id !== void 0;
+}
+function on() {
+  return typeof navigator == "object" && navigator.product === "ReactNative";
+}
+function an() {
+  const t = le();
+  return t.indexOf("MSIE ") >= 0 || t.indexOf("Trident/") >= 0;
+}
+function xe() {
+  try {
+    return typeof indexedDB == "object";
+  } catch {
+    return !1;
+  }
+}
+function Le() {
+  return new Promise((t, e) => {
+    try {
+      let n = !0;
+      const r = "validate-browser-context-for-indexeddb-analytics-module", s = self.indexedDB.open(r);
+      s.onsuccess = () => {
+        s.result.close(), n || self.indexedDB.deleteDatabase(r), t(!0);
+      }, s.onupgradeneeded = () => {
+        n = !1;
+      }, s.onerror = () => {
+        var i;
+        e(((i = s.error) === null || i === void 0 ? void 0 : i.message) || "");
+      };
+    } catch (n) {
+      e(n);
+    }
+  });
+}
+function cn() {
+  return !(typeof navigator > "u" || !navigator.cookieEnabled);
+}
+const Ne = "FirebaseError";
+class I extends Error {
+  constructor(e, n, r) {
+    super(n), this.code = e, this.customData = r, this.name = Ne, Object.setPrototypeOf(this, I.prototype), Error.captureStackTrace && Error.captureStackTrace(this, he.prototype.create);
+  }
+}
+class he {
+  constructor(e, n, r) {
+    this.service = e, this.serviceName = n, this.errors = r;
+  }
+  create(e, ...n) {
+    const r = n[0] || {}, s = `${this.service}/${e}`, i = this.errors[e], o = i ? $e(i, r) : "Error", l = `${this.serviceName}: ${o} (${s}).`;
+    return new I(s, l, r);
+  }
+}
+function $e(t, e) {
+  return t.replace(He, (n, r) => {
+    const s = e[r];
+    return s != null ? String(s) : `<${r}?>`;
+  });
+}
+const He = /\{\$([^}]+)}/g;
+function ln(t) {
+  for (const e in t)
+    if (Object.prototype.hasOwnProperty.call(t, e))
+      return !1;
+  return !0;
+}
+function H(t, e) {
+  if (t === e)
+    return !0;
+  const n = Object.keys(t), r = Object.keys(e);
+  for (const s of n) {
+    if (!r.includes(s))
+      return !1;
+    const i = t[s], o = e[s];
+    if (Z(i) && Z(o)) {
+      if (!H(i, o))
+        return !1;
+    } else if (i !== o)
+      return !1;
+  }
+  for (const s of r)
+    if (!n.includes(s))
+      return !1;
+  return !0;
+}
+function Z(t) {
+  return t !== null && typeof t == "object";
+}
+function dn(t) {
+  const e = [];
+  for (const [n, r] of Object.entries(t))
+    Array.isArray(r) ? r.forEach((s) => {
+      e.push(encodeURIComponent(n) + "=" + encodeURIComponent(s));
+    }) : e.push(encodeURIComponent(n) + "=" + encodeURIComponent(r));
+  return e.length ? "&" + e.join("&") : "";
+}
+function hn(t, e) {
+  const n = new Pe(t, e);
+  return n.subscribe.bind(n);
+}
+class Pe {
+  /**
+   * @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, n) {
+    this.observers = [], this.unsubscribes = [], this.observerCount = 0, this.task = Promise.resolve(), this.finalized = !1, this.onNoObservers = n, this.task.then(() => {
+      e(this);
+    }).catch((r) => {
+      this.error(r);
+    });
+  }
+  next(e) {
+    this.forEachObserver((n) => {
+      n.next(e);
+    });
+  }
+  error(e) {
+    this.forEachObserver((n) => {
+      n.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, n, r) {
+    let s;
+    if (e === void 0 && n === void 0 && r === void 0)
+      throw new Error("Missing Observer.");
+    ke(e, [
+      "next",
+      "error",
+      "complete"
+    ]) ? s = e : s = {
+      next: e,
+      error: n,
+      complete: r
+    }, s.next === void 0 && (s.next = R), s.error === void 0 && (s.error = R), s.complete === void 0 && (s.complete = R);
+    const i = this.unsubscribeOne.bind(this, this.observers.length);
+    return this.finalized && this.task.then(() => {
+      try {
+        this.finalError ? s.error(this.finalError) : s.complete();
+      } catch {
+      }
+    }), this.observers.push(s), i;
+  }
+  // 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 n = 0; n < this.observers.length; n++)
+        this.sendOne(n, 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, n) {
+    this.task.then(() => {
+      if (this.observers !== void 0 && this.observers[e] !== void 0)
+        try {
+          n(this.observers[e]);
+        } catch (r) {
+          typeof console < "u" && console.error && console.error(r);
+        }
+    });
+  }
+  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 ke(t, e) {
+  if (typeof t != "object" || t === null)
+    return !1;
+  for (const n of e)
+    if (n in t && typeof t[n] == "function")
+      return !0;
+  return !1;
+}
+function R() {
+}
+function un(t) {
+  return t && t._delegate ? t._delegate : t;
+}
+class B {
+  /**
+   *
+   * @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, n, r) {
+    this.name = e, this.instanceFactory = n, this.type = r, 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;
+  }
+}
+const b = "[DEFAULT]";
+class Fe {
+  constructor(e, n) {
+    this.name = e, this.container = n, 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 n = this.normalizeInstanceIdentifier(e);
+    if (!this.instancesDeferred.has(n)) {
+      const r = new Be();
+      if (this.instancesDeferred.set(n, r), this.isInitialized(n) || this.shouldAutoInitialize())
+        try {
+          const s = this.getOrInitializeService({
+            instanceIdentifier: n
+          });
+          s && r.resolve(s);
+        } catch {
+        }
+    }
+    return this.instancesDeferred.get(n).promise;
+  }
+  getImmediate(e) {
+    var n;
+    const r = this.normalizeInstanceIdentifier(e?.identifier), s = (n = e?.optional) !== null && n !== void 0 ? n : !1;
+    if (this.isInitialized(r) || this.shouldAutoInitialize())
+      try {
+        return this.getOrInitializeService({
+          instanceIdentifier: r
+        });
+      } catch (i) {
+        if (s)
+          return null;
+        throw i;
+      }
+    else {
+      if (s)
+        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 (je(e))
+        try {
+          this.getOrInitializeService({ instanceIdentifier: b });
+        } catch {
+        }
+      for (const [n, r] of this.instancesDeferred.entries()) {
+        const s = this.normalizeInstanceIdentifier(n);
+        try {
+          const i = this.getOrInitializeService({
+            instanceIdentifier: s
+          });
+          r.resolve(i);
+        } catch {
+        }
+      }
+    }
+  }
+  clearInstance(e = b) {
+    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((n) => "INTERNAL" in n).map((n) => n.INTERNAL.delete()),
+      ...e.filter((n) => "_delete" in n).map((n) => n._delete())
+    ]);
+  }
+  isComponentSet() {
+    return this.component != null;
+  }
+  isInitialized(e = b) {
+    return this.instances.has(e);
+  }
+  getOptions(e = b) {
+    return this.instancesOptions.get(e) || {};
+  }
+  initialize(e = {}) {
+    const { options: n = {} } = e, r = this.normalizeInstanceIdentifier(e.instanceIdentifier);
+    if (this.isInitialized(r))
+      throw Error(`${this.name}(${r}) has already been initialized`);
+    if (!this.isComponentSet())
+      throw Error(`Component ${this.name} has not been registered yet`);
+    const s = this.getOrInitializeService({
+      instanceIdentifier: r,
+      options: n
+    });
+    for (const [i, o] of this.instancesDeferred.entries()) {
+      const l = this.normalizeInstanceIdentifier(i);
+      r === l && o.resolve(s);
+    }
+    return s;
+  }
+  /**
+   *
+   * @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, n) {
+    var r;
+    const s = this.normalizeInstanceIdentifier(n), i = (r = this.onInitCallbacks.get(s)) !== null && r !== void 0 ? r : /* @__PURE__ */ new Set();
+    i.add(e), this.onInitCallbacks.set(s, i);
+    const o = this.instances.get(s);
+    return o && e(o, s), () => {
+      i.delete(e);
+    };
+  }
+  /**
+   * Invoke onInit callbacks synchronously
+   * @param instance the service instance`
+   */
+  invokeOnInitCallbacks(e, n) {
+    const r = this.onInitCallbacks.get(n);
+    if (r)
+      for (const s of r)
+        try {
+          s(e, n);
+        } catch {
+        }
+  }
+  getOrInitializeService({ instanceIdentifier: e, options: n = {} }) {
+    let r = this.instances.get(e);
+    if (!r && this.component && (r = this.component.instanceFactory(this.container, {
+      instanceIdentifier: ze(e),
+      options: n
+    }), this.instances.set(e, r), this.instancesOptions.set(e, n), this.invokeOnInitCallbacks(r, e), this.component.onInstanceCreated))
+      try {
+        this.component.onInstanceCreated(this.container, e, r);
+      } catch {
+      }
+    return r || null;
+  }
+  normalizeInstanceIdentifier(e = b) {
+    return this.component ? this.component.multipleInstances ? e : b : e;
+  }
+  shouldAutoInitialize() {
+    return !!this.component && this.component.instantiationMode !== "EXPLICIT";
+  }
+}
+function ze(t) {
+  return t === b ? void 0 : t;
+}
+function je(t) {
+  return t.instantiationMode === "EAGER";
+}
+class ue {
+  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 n = this.getProvider(e.name);
+    if (n.isComponentSet())
+      throw new Error(`Component ${e.name} has already been registered with ${this.name}`);
+    n.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 n = new Fe(e, this);
+    return this.providers.set(e, n), n;
+  }
+  getProviders() {
+    return Array.from(this.providers.values());
+  }
+}
+const V = [];
+var d;
+(function(t) {
+  t[t.DEBUG = 0] = "DEBUG", t[t.VERBOSE = 1] = "VERBOSE", t[t.INFO = 2] = "INFO", t[t.WARN = 3] = "WARN", t[t.ERROR = 4] = "ERROR", t[t.SILENT = 5] = "SILENT";
+})(d || (d = {}));
+const fe = {
+  debug: d.DEBUG,
+  verbose: d.VERBOSE,
+  info: d.INFO,
+  warn: d.WARN,
+  error: d.ERROR,
+  silent: d.SILENT
+}, Ve = d.INFO, Ue = {
+  [d.DEBUG]: "log",
+  [d.VERBOSE]: "log",
+  [d.INFO]: "info",
+  [d.WARN]: "warn",
+  [d.ERROR]: "error"
+}, We = (t, e, ...n) => {
+  if (e < t.logLevel)
+    return;
+  const r = (/* @__PURE__ */ new Date()).toISOString(), s = Ue[e];
+  if (s)
+    console[s](`[${r}]  ${t.name}:`, ...n);
+  else
+    throw new Error(`Attempted to log a message with an invalid logType (value: ${e})`);
+};
+class Ge {
+  /**
+   * 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 = Ve, this._logHandler = We, this._userLogHandler = null, V.push(this);
+  }
+  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" ? fe[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);
+  }
+}
+function Je(t) {
+  V.forEach((e) => {
+    e.setLogLevel(t);
+  });
+}
+function Ke(t, e) {
+  for (const n of V) {
+    let r = null;
+    e && e.level && (r = fe[e.level]), t === null ? n.userLogHandler = null : n.userLogHandler = (s, i, ...o) => {
+      const l = o.map((c) => {
+        if (c == null)
+          return null;
+        if (typeof c == "string")
+          return c;
+        if (typeof c == "number" || typeof c == "boolean")
+          return c.toString();
+        if (c instanceof Error)
+          return c.message;
+        try {
+          return JSON.stringify(c);
+        } catch {
+          return null;
+        }
+      }).filter((c) => c).join(" ");
+      i >= (r ?? s.logLevel) && t({
+        level: d[i].toLowerCase(),
+        message: l,
+        args: o,
+        type: s.name
+      });
+    };
+  }
+}
+const Ze = (t, e) => e.some((n) => t instanceof n);
+let Y, q;
+function Ye() {
+  return Y || (Y = [
+    IDBDatabase,
+    IDBObjectStore,
+    IDBIndex,
+    IDBCursor,
+    IDBTransaction
+  ]);
+}
+function qe() {
+  return q || (q = [
+    IDBCursor.prototype.advance,
+    IDBCursor.prototype.continue,
+    IDBCursor.prototype.continuePrimaryKey
+  ]);
+}
+const pe = /* @__PURE__ */ new WeakMap(), P = /* @__PURE__ */ new WeakMap(), me = /* @__PURE__ */ new WeakMap(), x = /* @__PURE__ */ new WeakMap(), U = /* @__PURE__ */ new WeakMap();
+function Xe(t) {
+  const e = new Promise((n, r) => {
+    const s = () => {
+      t.removeEventListener("success", i), t.removeEventListener("error", o);
+    }, i = () => {
+      n(m(t.result)), s();
+    }, o = () => {
+      r(t.error), s();
+    };
+    t.addEventListener("success", i), t.addEventListener("error", o);
+  });
+  return e.then((n) => {
+    n instanceof IDBCursor && pe.set(n, t);
+  }).catch(() => {
+  }), U.set(e, t), e;
+}
+function Qe(t) {
+  if (P.has(t))
+    return;
+  const e = new Promise((n, r) => {
+    const s = () => {
+      t.removeEventListener("complete", i), t.removeEventListener("error", o), t.removeEventListener("abort", o);
+    }, i = () => {
+      n(), s();
+    }, o = () => {
+      r(t.error || new DOMException("AbortError", "AbortError")), s();
+    };
+    t.addEventListener("complete", i), t.addEventListener("error", o), t.addEventListener("abort", o);
+  });
+  P.set(t, e);
+}
+let k = {
+  get(t, e, n) {
+    if (t instanceof IDBTransaction) {
+      if (e === "done")
+        return P.get(t);
+      if (e === "objectStoreNames")
+        return t.objectStoreNames || me.get(t);
+      if (e === "store")
+        return n.objectStoreNames[1] ? void 0 : n.objectStore(n.objectStoreNames[0]);
+    }
+    return m(t[e]);
+  },
+  set(t, e, n) {
+    return t[e] = n, !0;
+  },
+  has(t, e) {
+    return t instanceof IDBTransaction && (e === "done" || e === "store") ? !0 : e in t;
+  }
+};
+function et(t) {
+  k = t(k);
+}
+function tt(t) {
+  return t === IDBDatabase.prototype.transaction && !("objectStoreNames" in IDBTransaction.prototype) ? function(e, ...n) {
+    const r = t.call(L(this), e, ...n);
+    return me.set(r, e.sort ? e.sort() : [e]), m(r);
+  } : qe().includes(t) ? function(...e) {
+    return t.apply(L(this), e), m(pe.get(this));
+  } : function(...e) {
+    return m(t.apply(L(this), e));
+  };
+}
+function nt(t) {
+  return typeof t == "function" ? tt(t) : (t instanceof IDBTransaction && Qe(t), Ze(t, Ye()) ? new Proxy(t, k) : t);
+}
+function m(t) {
+  if (t instanceof IDBRequest)
+    return Xe(t);
+  if (x.has(t))
+    return x.get(t);
+  const e = nt(t);
+  return e !== t && (x.set(t, e), U.set(e, t)), e;
+}
+const L = (t) => U.get(t);
+function rt(t, e, { blocked: n, upgrade: r, blocking: s, terminated: i } = {}) {
+  const o = indexedDB.open(t, e), l = m(o);
+  return r && o.addEventListener("upgradeneeded", (c) => {
+    r(m(o.result), c.oldVersion, c.newVersion, m(o.transaction), c);
+  }), n && o.addEventListener("blocked", (c) => n(
+    // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+    c.oldVersion,
+    c.newVersion,
+    c
+  )), l.then((c) => {
+    i && c.addEventListener("close", () => i()), s && c.addEventListener("versionchange", (h) => s(h.oldVersion, h.newVersion, h));
+  }).catch(() => {
+  }), l;
+}
+function fn(t, { blocked: e } = {}) {
+  const n = indexedDB.deleteDatabase(t);
+  return e && n.addEventListener("blocked", (r) => e(
+    // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+    r.oldVersion,
+    r
+  )), m(n).then(() => {
+  });
+}
+const st = ["get", "getKey", "getAll", "getAllKeys", "count"], it = ["put", "add", "delete", "clear"], N = /* @__PURE__ */ new Map();
+function X(t, e) {
+  if (!(t instanceof IDBDatabase && !(e in t) && typeof e == "string"))
+    return;
+  if (N.get(e))
+    return N.get(e);
+  const n = e.replace(/FromIndex$/, ""), r = e !== n, s = it.includes(n);
+  if (
+    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
+    !(n in (r ? IDBIndex : IDBObjectStore).prototype) || !(s || st.includes(n))
+  )
+    return;
+  const i = async function(o, ...l) {
+    const c = this.transaction(o, s ? "readwrite" : "readonly");
+    let h = c.store;
+    return r && (h = h.index(l.shift())), (await Promise.all([
+      h[n](...l),
+      s && c.done
+    ]))[0];
+  };
+  return N.set(e, i), i;
+}
+et((t) => ({
+  ...t,
+  get: (e, n, r) => X(e, n) || t.get(e, n, r),
+  has: (e, n) => !!X(e, n) || t.has(e, n)
+}));
+class ot {
+  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((n) => {
+      if (at(n)) {
+        const r = n.getImmediate();
+        return `${r.library}/${r.version}`;
+      } else
+        return null;
+    }).filter((n) => n).join(" ");
+  }
+}
+function at(t) {
+  const e = t.getComponent();
+  return e?.type === "VERSION";
+}
+const O = "@firebase/app", F = "0.13.1";
+const g = new Ge("@firebase/app"), ct = "@firebase/app-compat", lt = "@firebase/analytics-compat", dt = "@firebase/analytics", ht = "@firebase/app-check-compat", ut = "@firebase/app-check", ft = "@firebase/auth", pt = "@firebase/auth-compat", mt = "@firebase/database", gt = "@firebase/data-connect", bt = "@firebase/database-compat", yt = "@firebase/functions", vt = "@firebase/functions-compat", _t = "@firebase/installations", Et = "@firebase/installations-compat", Ct = "@firebase/messaging", wt = "@firebase/messaging-compat", Dt = "@firebase/performance", It = "@firebase/performance-compat", St = "@firebase/remote-config", At = "@firebase/remote-config-compat", Bt = "@firebase/storage", Ot = "@firebase/storage-compat", Tt = "@firebase/firestore", Mt = "@firebase/ai", Rt = "@firebase/firestore-compat", xt = "firebase", Lt = "11.9.0";
+const T = "[DEFAULT]", Nt = {
+  [O]: "fire-core",
+  [ct]: "fire-core-compat",
+  [dt]: "fire-analytics",
+  [lt]: "fire-analytics-compat",
+  [ut]: "fire-app-check",
+  [ht]: "fire-app-check-compat",
+  [ft]: "fire-auth",
+  [pt]: "fire-auth-compat",
+  [mt]: "fire-rtdb",
+  [gt]: "fire-data-connect",
+  [bt]: "fire-rtdb-compat",
+  [yt]: "fire-fn",
+  [vt]: "fire-fn-compat",
+  [_t]: "fire-iid",
+  [Et]: "fire-iid-compat",
+  [Ct]: "fire-fcm",
+  [wt]: "fire-fcm-compat",
+  [Dt]: "fire-perf",
+  [It]: "fire-perf-compat",
+  [St]: "fire-rc",
+  [At]: "fire-rc-compat",
+  [Bt]: "fire-gcs",
+  [Ot]: "fire-gcs-compat",
+  [Tt]: "fire-fst",
+  [Rt]: "fire-fst-compat",
+  [Mt]: "fire-vertex",
+  "fire-js": "fire-js",
+  // Platform identifier for JS SDK.
+  [xt]: "fire-js-all"
+};
+const y = /* @__PURE__ */ new Map(), C = /* @__PURE__ */ new Map(), w = /* @__PURE__ */ new Map();
+function Q(t, e) {
+  try {
+    t.container.addComponent(e);
+  } catch (n) {
+    g.debug(`Component ${e.name} failed to register with FirebaseApp ${t.name}`, n);
+  }
+}
+function pn(t, e) {
+  t.container.addOrOverwriteComponent(e);
+}
+function z(t) {
+  const e = t.name;
+  if (w.has(e))
+    return g.debug(`There were multiple attempts to register component ${e}.`), !1;
+  w.set(e, t);
+  for (const n of y.values())
+    Q(n, t);
+  for (const n of C.values())
+    Q(n, t);
+  return !0;
+}
+function $t(t, e) {
+  const n = t.container.getProvider("heartbeat").getImmediate({ optional: !0 });
+  return n && n.triggerHeartbeat(), t.container.getProvider(e);
+}
+function mn(t, e, n = T) {
+  $t(t, e).clearInstance(n);
+}
+function Ht(t) {
+  return t.options !== void 0;
+}
+function gn(t) {
+  return t == null ? !1 : t.settings !== void 0;
+}
+function bn() {
+  w.clear();
+}
+const Pt = {
+  "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."
+}, u = new he("app", "Firebase", Pt);
+class ge {
+  constructor(e, n, r) {
+    this._isDeleted = !1, this._options = Object.assign({}, e), this._config = Object.assign({}, n), this._name = n.name, this._automaticDataCollectionEnabled = n.automaticDataCollectionEnabled, this._container = r, this.container.addComponent(new B(
+      "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 u.create("app-deleted", { appName: this._name });
+  }
+}
+function ee(t, e) {
+  const n = ae(t.split(".")[1]);
+  if (n === null) {
+    console.error(`FirebaseServerApp ${e} is invalid: second part could not be parsed.`);
+    return;
+  }
+  if (JSON.parse(n).exp === void 0) {
+    console.error(`FirebaseServerApp ${e} is invalid: expiration claim could not be parsed`);
+    return;
+  }
+  const s = JSON.parse(n).exp * 1e3, i = (/* @__PURE__ */ new Date()).getTime();
+  s - i <= 0 && console.error(`FirebaseServerApp ${e} is invalid: the token has expired.`);
+}
+class kt extends ge {
+  constructor(e, n, r, s) {
+    const i = n.automaticDataCollectionEnabled !== void 0 ? n.automaticDataCollectionEnabled : !0, o = {
+      name: r,
+      automaticDataCollectionEnabled: i
+    };
+    if (e.apiKey !== void 0)
+      super(e, o, s);
+    else {
+      const l = e;
+      super(l.options, o, s);
+    }
+    this._serverConfig = Object.assign({ automaticDataCollectionEnabled: i }, n), this._serverConfig.authIdToken && ee(this._serverConfig.authIdToken, "authIdToken"), this._serverConfig.appCheckToken && ee(this._serverConfig.appCheckToken, "appCheckToken"), this._finalizationRegistry = null, typeof FinalizationRegistry < "u" && (this._finalizationRegistry = new FinalizationRegistry(() => {
+      this.automaticCleanup();
+    })), this._refCount = 0, this.incRefCount(this._serverConfig.releaseOnDeref), this._serverConfig.releaseOnDeref = void 0, n.releaseOnDeref = void 0, A(O, F, "serverapp");
+  }
+  toJSON() {
+  }
+  get refCount() {
+    return this._refCount;
+  }
+  // Increment the reference count of this server app. If an object is provided, register it
+  // with the finalization registry.
+  incRefCount(e) {
+    this.isDeleted || (this._refCount++, e !== void 0 && this._finalizationRegistry !== null && this._finalizationRegistry.register(e, this));
+  }
+  // Decrement the reference count.
+  decRefCount() {
+    return this.isDeleted ? 0 : --this._refCount;
+  }
+  // Invoked by the FinalizationRegistry callback to note that this app should go through its
+  // reference counts and delete itself if no reference count remain. The coordinating logic that
+  // handles this is in deleteApp(...).
+  automaticCleanup() {
+    zt(this);
+  }
+  get settings() {
+    return this.checkDestroyed(), this._serverConfig;
+  }
+  /**
+   * This function will throw an Error if the App has already been deleted -
+   * use before performing API actions on the App.
+   */
+  checkDestroyed() {
+    if (this.isDeleted)
+      throw u.create(
+        "server-app-deleted"
+        /* AppError.SERVER_APP_DELETED */
+      );
+  }
+}
+const yn = Lt;
+function Ft(t, e = {}) {
+  let n = t;
+  typeof e != "object" && (e = { name: e });
+  const r = Object.assign({ name: T, automaticDataCollectionEnabled: !0 }, e), s = r.name;
+  if (typeof s != "string" || !s)
+    throw u.create("bad-app-name", {
+      appName: String(s)
+    });
+  if (n || (n = ce()), !n)
+    throw u.create(
+      "no-options"
+      /* AppError.NO_OPTIONS */
+    );
+  const i = y.get(s);
+  if (i) {
+    if (H(n, i.options) && H(r, i.config))
+      return i;
+    throw u.create("duplicate-app", { appName: s });
+  }
+  const o = new ue(s);
+  for (const c of w.values())
+    o.addComponent(c);
+  const l = new ge(n, r, o);
+  return y.set(s, l), l;
+}
+function vn(t, e) {
+  if (Re() && !de())
+    throw u.create(
+      "invalid-server-app-environment"
+      /* AppError.INVALID_SERVER_APP_ENVIRONMENT */
+    );
+  e.automaticDataCollectionEnabled === void 0 && (e.automaticDataCollectionEnabled = !0);
+  let n;
+  Ht(t) ? n = t.options : n = t;
+  const r = Object.assign(Object.assign({}, e), n);
+  r.releaseOnDeref !== void 0 && delete r.releaseOnDeref;
+  const s = (h) => [...h].reduce((v, p) => Math.imul(31, v) + p.charCodeAt(0) | 0, 0);
+  if (e.releaseOnDeref !== void 0 && typeof FinalizationRegistry > "u")
+    throw u.create("finalization-registry-not-supported", {});
+  const i = "" + s(JSON.stringify(r)), o = C.get(i);
+  if (o)
+    return o.incRefCount(e.releaseOnDeref), o;
+  const l = new ue(i);
+  for (const h of w.values())
+    l.addComponent(h);
+  const c = new kt(n, e, i, l);
+  return C.set(i, c), c;
+}
+function _n(t = T) {
+  const e = y.get(t);
+  if (!e && t === T && ce())
+    return Ft();
+  if (!e)
+    throw u.create("no-app", { appName: t });
+  return e;
+}
+function En() {
+  return Array.from(y.values());
+}
+async function zt(t) {
+  let e = !1;
+  const n = t.name;
+  y.has(n) ? (e = !0, y.delete(n)) : C.has(n) && t.decRefCount() <= 0 && (C.delete(n), e = !0), e && (await Promise.all(t.container.getProviders().map((r) => r.delete())), t.isDeleted = !0);
+}
+function A(t, e, n) {
+  var r;
+  let s = (r = Nt[t]) !== null && r !== void 0 ? r : t;
+  n && (s += `-${n}`);
+  const i = s.match(/\s|\//), o = e.match(/\s|\//);
+  if (i || o) {
+    const l = [
+      `Unable to register library "${s}" with version "${e}":`
+    ];
+    i && l.push(`library name "${s}" contains illegal characters (whitespace or "/")`), i && o && l.push("and"), o && l.push(`version name "${e}" contains illegal characters (whitespace or "/")`), g.warn(l.join(" "));
+    return;
+  }
+  z(new B(
+    `${s}-version`,
+    () => ({ library: s, version: e }),
+    "VERSION"
+    /* ComponentType.VERSION */
+  ));
+}
+function Cn(t, e) {
+  if (t !== null && typeof t != "function")
+    throw u.create(
+      "invalid-log-argument"
+      /* AppError.INVALID_LOG_ARGUMENT */
+    );
+  Ke(t, e);
+}
+function wn(t) {
+  Je(t);
+}
+const jt = "firebase-heartbeat-database", Vt = 1, D = "firebase-heartbeat-store";
+let $ = null;
+function be() {
+  return $ || ($ = rt(jt, Vt, {
+    upgrade: (t, e) => {
+      switch (e) {
+        case 0:
+          try {
+            t.createObjectStore(D);
+          } catch (n) {
+            console.warn(n);
+          }
+      }
+    }
+  }).catch((t) => {
+    throw u.create("idb-open", {
+      originalErrorMessage: t.message
+    });
+  })), $;
+}
+async function Ut(t) {
+  try {
+    const n = (await be()).transaction(D), r = await n.objectStore(D).get(ye(t));
+    return await n.done, r;
+  } catch (e) {
+    if (e instanceof I)
+      g.warn(e.message);
+    else {
+      const n = u.create("idb-get", {
+        originalErrorMessage: e?.message
+      });
+      g.warn(n.message);
+    }
+  }
+}
+async function te(t, e) {
+  try {
+    const r = (await be()).transaction(D, "readwrite");
+    await r.objectStore(D).put(e, ye(t)), await r.done;
+  } catch (n) {
+    if (n instanceof I)
+      g.warn(n.message);
+    else {
+      const r = u.create("idb-set", {
+        originalErrorMessage: n?.message
+      });
+      g.warn(r.message);
+    }
+  }
+}
+function ye(t) {
+  return `${t.name}!${t.options.appId}`;
+}
+const Wt = 1024, Gt = 30;
+class Jt {
+  constructor(e) {
+    this.container = e, this._heartbeatsCache = null;
+    const n = this.container.getProvider("app").getImmediate();
+    this._storage = new Zt(n), this._heartbeatsCachePromise = this._storage.read().then((r) => (this._heartbeatsCache = r, r));
+  }
+  /**
+   * 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, n;
+    try {
+      const s = this.container.getProvider("platform-logger").getImmediate().getPlatformInfoString(), i = ne();
+      if (((e = this._heartbeatsCache) === null || e === void 0 ? void 0 : e.heartbeats) == null && (this._heartbeatsCache = await this._heartbeatsCachePromise, ((n = this._heartbeatsCache) === null || n === void 0 ? void 0 : n.heartbeats) == null) || this._heartbeatsCache.lastSentHeartbeatDate === i || this._heartbeatsCache.heartbeats.some((o) => o.date === i))
+        return;
+      if (this._heartbeatsCache.heartbeats.push({ date: i, agent: s }), this._heartbeatsCache.heartbeats.length > Gt) {
+        const o = Yt(this._heartbeatsCache.heartbeats);
+        this._heartbeatsCache.heartbeats.splice(o, 1);
+      }
+      return this._storage.overwrite(this._heartbeatsCache);
+    } catch (r) {
+      g.warn(r);
+    }
+  }
+  /**
+   * 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 n = ne(), { heartbeatsToSend: r, unsentEntries: s } = Kt(this._heartbeatsCache.heartbeats), i = oe(JSON.stringify({ version: 2, heartbeats: r }));
+      return this._heartbeatsCache.lastSentHeartbeatDate = n, s.length > 0 ? (this._heartbeatsCache.heartbeats = s, await this._storage.overwrite(this._heartbeatsCache)) : (this._heartbeatsCache.heartbeats = [], this._storage.overwrite(this._heartbeatsCache)), i;
+    } catch (n) {
+      return g.warn(n), "";
+    }
+  }
+}
+function ne() {
+  return (/* @__PURE__ */ new Date()).toISOString().substring(0, 10);
+}
+function Kt(t, e = Wt) {
+  const n = [];
+  let r = t.slice();
+  for (const s of t) {
+    const i = n.find((o) => o.agent === s.agent);
+    if (i) {
+      if (i.dates.push(s.date), re(n) > e) {
+        i.dates.pop();
+        break;
+      }
+    } else if (n.push({
+      agent: s.agent,
+      dates: [s.date]
+    }), re(n) > e) {
+      n.pop();
+      break;
+    }
+    r = r.slice(1);
+  }
+  return {
+    heartbeatsToSend: n,
+    unsentEntries: r
+  };
+}
+class Zt {
+  constructor(e) {
+    this.app = e, this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();
+  }
+  async runIndexedDBEnvironmentCheck() {
+    return xe() ? Le().then(() => !0).catch(() => !1) : !1;
+  }
+  /**
+   * Read all heartbeats.
+   */
+  async read() {
+    if (await this._canUseIndexedDBPromise) {
+      const n = await Ut(this.app);
+      return n?.heartbeats ? n : { heartbeats: [] };
+    } else
+      return { heartbeats: [] };
+  }
+  // overwrite the storage with the provided heartbeats
+  async overwrite(e) {
+    var n;
+    if (await this._canUseIndexedDBPromise) {
+      const s = await this.read();
+      return te(this.app, {
+        lastSentHeartbeatDate: (n = e.lastSentHeartbeatDate) !== null && n !== void 0 ? n : s.lastSentHeartbeatDate,
+        heartbeats: e.heartbeats
+      });
+    } else
+      return;
+  }
+  // add heartbeats
+  async add(e) {
+    var n;
+    if (await this._canUseIndexedDBPromise) {
+      const s = await this.read();
+      return te(this.app, {
+        lastSentHeartbeatDate: (n = e.lastSentHeartbeatDate) !== null && n !== void 0 ? n : s.lastSentHeartbeatDate,
+        heartbeats: [
+          ...s.heartbeats,
+          ...e.heartbeats
+        ]
+      });
+    } else
+      return;
+  }
+}
+function re(t) {
+  return oe(
+    // heartbeatsCache wrapper properties
+    JSON.stringify({ version: 2, heartbeats: t })
+  ).length;
+}
+function Yt(t) {
+  if (t.length === 0)
+    return -1;
+  let e = 0, n = t[0].date;
+  for (let r = 1; r < t.length; r++)
+    t[r].date < n && (n = t[r].date, e = r);
+  return e;
+}
+function qt(t) {
+  z(new B(
+    "platform-logger",
+    (e) => new ot(e),
+    "PRIVATE"
+    /* ComponentType.PRIVATE */
+  )), z(new B(
+    "heartbeat",
+    (e) => new Jt(e),
+    "PRIVATE"
+    /* ComponentType.PRIVATE */
+  )), A(O, F, t), A(O, F, "esm2017"), A("fire-js", "");
+}
+qt("");
+export {
+  hn as A,
+  Ft as B,
+  B as C,
+  En as D,
+  he as E,
+  I as F,
+  T as G,
+  Q as H,
+  pn as I,
+  y as J,
+  bn as K,
+  Ge as L,
+  w as M,
+  Ht as N,
+  mn as O,
+  C as P,
+  zt as Q,
+  vn as R,
+  yn as S,
+  Cn as T,
+  wn as U,
+  z as _,
+  $t as a,
+  _n as b,
+  cn as c,
+  fn as d,
+  gn as e,
+  Qt as f,
+  un as g,
+  Xt as h,
+  xe as i,
+  H as j,
+  Oe as k,
+  nn as l,
+  on as m,
+  le as n,
+  rt as o,
+  en as p,
+  dn as q,
+  A as r,
+  an as s,
+  ln as t,
+  tn as u,
+  Le as v,
+  sn as w,
+  d as x,
+  ae as y,
+  rn as z
+};