@lystech/sections 0.2.0 → 0.4.0

package/dist/morceaux/index.esm-Bd0PBW01.js

@@ -0,0 +1,1541 @@
+const ue = () => {
+};
+const X = 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;
+}, pe = 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++], c = t[n++], a = ((s & 7) << 18 | (i & 63) << 12 | (o & 63) << 6 | c & 63) - 65536;
+      e[r++] = String.fromCharCode(55296 + (a >> 10)), e[r++] = String.fromCharCode(56320 + (a & 1023));
+    } else {
+      const i = t[n++], o = t[n++];
+      e[r++] = String.fromCharCode((s & 15) << 12 | (i & 63) << 6 | o & 63);
+    }
+  }
+  return e.join("");
+}, Q = {
+  /**
+   * 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, c = o ? t[s + 1] : 0, a = s + 2 < t.length, f = a ? t[s + 2] : 0, b = i >> 2, p = (i & 3) << 4 | c >> 4;
+      let y = (c & 15) << 2 | f >> 6, C = f & 63;
+      a || (C = 64, o || (y = 64)), r.push(n[b], n[p], n[y], n[C]);
+    }
+    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(X(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) : pe(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++)], c = s < t.length ? n[t.charAt(s)] : 0;
+      ++s;
+      const f = s < t.length ? n[t.charAt(s)] : 64;
+      ++s;
+      const p = s < t.length ? n[t.charAt(s)] : 64;
+      if (++s, i == null || c == null || f == null || p == null)
+        throw new me();
+      const y = i << 2 | c >> 4;
+      if (r.push(y), f !== 64) {
+        const C = c << 4 & 240 | f >> 2;
+        if (r.push(C), p !== 64) {
+          const de = f << 6 & 192 | p;
+          r.push(de);
+        }
+      }
+    }
+    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 me extends Error {
+  constructor() {
+    super(...arguments), this.name = "DecodeBase64StringError";
+  }
+}
+const ge = function(t) {
+  const e = X(t);
+  return Q.encodeByteArray(e, !0);
+}, Z = function(t) {
+  return ge(t).replace(/\./g, "");
+}, ee = function(t) {
+  try {
+    return Q.decodeString(t, !0);
+  } catch (e) {
+    console.error("base64Decode failed: ", e);
+  }
+  return null;
+};
+function be() {
+  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.");
+}
+const ye = () => be().__FIREBASE_DEFAULTS__, Ee = () => {
+  if (typeof process > "u" || typeof process.env > "u")
+    return;
+  const t = process.env.__FIREBASE_DEFAULTS__;
+  if (t)
+    return JSON.parse(t);
+}, _e = () => {
+  if (typeof document > "u")
+    return;
+  let t;
+  try {
+    t = document.cookie.match(/__FIREBASE_DEFAULTS__=([^;]+)/);
+  } catch {
+    return;
+  }
+  const e = t && ee(t[1]);
+  return e && JSON.parse(e);
+}, P = () => {
+  try {
+    return ue() || ye() || Ee() || _e();
+  } catch (t) {
+    console.info(`Unable to get __FIREBASE_DEFAULTS__ due to: ${t}`);
+    return;
+  }
+}, zt = (t) => P()?.emulatorHosts?.[t], H = () => P()?.config, Vt = (t) => P()?.[`_${t}`];
+class ve {
+  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 te() {
+  return typeof navigator < "u" && typeof navigator.userAgent == "string" ? navigator.userAgent : "";
+}
+function Ut() {
+  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(te());
+}
+function we() {
+  return typeof window < "u" || ne();
+}
+function ne() {
+  return typeof WorkerGlobalScope < "u" && typeof self < "u" && self instanceof WorkerGlobalScope;
+}
+function Wt() {
+  return typeof navigator < "u" && navigator.userAgent === "Cloudflare-Workers";
+}
+function jt() {
+  const t = typeof chrome == "object" ? chrome.runtime : typeof browser == "object" ? browser.runtime : void 0;
+  return typeof t == "object" && t.id !== void 0;
+}
+function Gt() {
+  return typeof navigator == "object" && navigator.product === "ReactNative";
+}
+function Jt() {
+  const t = te();
+  return t.indexOf("MSIE ") >= 0 || t.indexOf("Trident/") >= 0;
+}
+function Ce() {
+  try {
+    return typeof indexedDB == "object";
+  } catch {
+    return !1;
+  }
+}
+function De() {
+  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 = () => {
+        e(s.error?.message || "");
+      };
+    } catch (n) {
+      e(n);
+    }
+  });
+}
+const Ie = "FirebaseError";
+class w extends Error {
+  constructor(e, n, r) {
+    super(n), this.code = e, this.customData = r, this.name = Ie, Object.setPrototypeOf(this, w.prototype), Error.captureStackTrace && Error.captureStackTrace(this, re.prototype.create);
+  }
+}
+class re {
+  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 ? Se(i, r) : "Error", c = `${this.serviceName}: ${o} (${s}).`;
+    return new w(s, c, r);
+  }
+}
+function Se(t, e) {
+  try {
+    let n = 0, r = "";
+    for (; n < t.length; ) {
+      const s = t.indexOf("{$", n);
+      if (s === -1) {
+        r += t.substring(n);
+        break;
+      }
+      const i = t.indexOf("}", s + 2);
+      if (i === -1) {
+        r += t.substring(n);
+        break;
+      }
+      const o = t.substring(s + 2, i), c = e[o];
+      r += t.substring(n, s) + (c != null ? String(c) : `<${o}?>`), n = i + 1;
+    }
+    return r;
+  } catch {
+    return t;
+  }
+}
+function Kt(t) {
+  for (const e in t)
+    if (Object.prototype.hasOwnProperty.call(t, e))
+      return !1;
+  return !0;
+}
+function N(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 (V(i) && V(o)) {
+      if (!N(i, o))
+        return !1;
+    } else if (i !== o)
+      return !1;
+  }
+  for (const s of r)
+    if (!n.includes(s))
+      return !1;
+  return !0;
+}
+function V(t) {
+  return t !== null && typeof t == "object";
+}
+function Yt(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 qt(t) {
+  const e = {};
+  return t.replace(/^\?/, "").split("&").forEach((r) => {
+    if (r) {
+      const [s, i] = r.split("=");
+      e[decodeURIComponent(s)] = decodeURIComponent(i);
+    }
+  }), e;
+}
+function Xt(t) {
+  const e = t.indexOf("?");
+  if (!e)
+    return "";
+  const n = t.indexOf("#", e);
+  return t.substring(e, n > 0 ? n : void 0);
+}
+function Qt(t, e) {
+  const n = new Ae(t, e);
+  return n.subscribe.bind(n);
+}
+class Ae {
+  /**
+   * @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.");
+    Oe(e, [
+      "next",
+      "error",
+      "complete"
+    ]) ? s = e : s = {
+      next: e,
+      error: n,
+      complete: r
+    }, s.next === void 0 && (s.next = O), s.error === void 0 && (s.error = O), s.complete === void 0 && (s.complete = O);
+    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 Oe(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 O() {
+}
+function Zt(t) {
+  return t && t._delegate ? t._delegate : t;
+}
+function en(t) {
+  try {
+    return (t.startsWith("http://") || t.startsWith("https://") ? new URL(t).hostname : t).endsWith(".cloudworkstations.dev");
+  } catch {
+    return !1;
+  }
+}
+async function tn(t) {
+  return (await fetch(t, {
+    credentials: "include"
+  })).ok;
+}
+class I {
+  /**
+   *
+   * @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 m = "[DEFAULT]";
+class Be {
+  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 ve();
+      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) {
+    const n = this.normalizeInstanceIdentifier(e?.identifier), r = e?.optional ?? !1;
+    if (this.isInitialized(n) || this.shouldAutoInitialize())
+      try {
+        return this.getOrInitializeService({
+          instanceIdentifier: n
+        });
+      } catch (s) {
+        if (r)
+          return null;
+        throw s;
+      }
+    else {
+      if (r)
+        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 (Re(e))
+        try {
+          this.getOrInitializeService({ instanceIdentifier: m });
+        } 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 = m) {
+    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 = m) {
+    return this.instances.has(e);
+  }
+  getOptions(e = m) {
+    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 c = this.normalizeInstanceIdentifier(i);
+      r === c && 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) {
+    const r = this.normalizeInstanceIdentifier(n), s = this.onInitCallbacks.get(r) ?? /* @__PURE__ */ new Set();
+    s.add(e), this.onInitCallbacks.set(r, s);
+    const i = this.instances.get(r);
+    return i && e(i, r), () => {
+      s.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: Te(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 = m) {
+    return this.component ? this.component.multipleInstances ? e : m : e;
+  }
+  shouldAutoInitialize() {
+    return !!this.component && this.component.instantiationMode !== "EXPLICIT";
+  }
+}
+function Te(t) {
+  return t === m ? void 0 : t;
+}
+function Re(t) {
+  return t.instantiationMode === "EAGER";
+}
+class se {
+  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 Be(e, this);
+    return this.providers.set(e, n), n;
+  }
+  getProviders() {
+    return Array.from(this.providers.values());
+  }
+}
+const F = [];
+var l;
+(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";
+})(l || (l = {}));
+const ie = {
+  debug: l.DEBUG,
+  verbose: l.VERBOSE,
+  info: l.INFO,
+  warn: l.WARN,
+  error: l.ERROR,
+  silent: l.SILENT
+}, xe = l.INFO, Ne = {
+  [l.DEBUG]: "log",
+  [l.VERBOSE]: "log",
+  [l.INFO]: "info",
+  [l.WARN]: "warn",
+  [l.ERROR]: "error"
+}, Me = (t, e, ...n) => {
+  if (e < t.logLevel)
+    return;
+  const r = (/* @__PURE__ */ new Date()).toISOString(), s = Ne[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 $e {
+  /**
+   * 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 = xe, this._logHandler = Me, this._userLogHandler = null, F.push(this);
+  }
+  get logLevel() {
+    return this._logLevel;
+  }
+  set logLevel(e) {
+    if (!(e in l))
+      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" ? ie[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, l.DEBUG, ...e), this._logHandler(this, l.DEBUG, ...e);
+  }
+  log(...e) {
+    this._userLogHandler && this._userLogHandler(this, l.VERBOSE, ...e), this._logHandler(this, l.VERBOSE, ...e);
+  }
+  info(...e) {
+    this._userLogHandler && this._userLogHandler(this, l.INFO, ...e), this._logHandler(this, l.INFO, ...e);
+  }
+  warn(...e) {
+    this._userLogHandler && this._userLogHandler(this, l.WARN, ...e), this._logHandler(this, l.WARN, ...e);
+  }
+  error(...e) {
+    this._userLogHandler && this._userLogHandler(this, l.ERROR, ...e), this._logHandler(this, l.ERROR, ...e);
+  }
+}
+function Le(t) {
+  F.forEach((e) => {
+    e.setLogLevel(t);
+  });
+}
+function ke(t, e) {
+  for (const n of F) {
+    let r = null;
+    e && e.level && (r = ie[e.level]), t === null ? n.userLogHandler = null : n.userLogHandler = (s, i, ...o) => {
+      const c = o.map((a) => {
+        if (a == null)
+          return null;
+        if (typeof a == "string")
+          return a;
+        if (typeof a == "number" || typeof a == "boolean")
+          return a.toString();
+        if (a instanceof Error)
+          return a.message;
+        try {
+          return JSON.stringify(a);
+        } catch {
+          return null;
+        }
+      }).filter((a) => a).join(" ");
+      i >= (r ?? s.logLevel) && t({
+        level: l[i].toLowerCase(),
+        message: c,
+        args: o,
+        type: s.name
+      });
+    };
+  }
+}
+const Pe = (t, e) => e.some((n) => t instanceof n);
+let U, W;
+function He() {
+  return U || (U = [
+    IDBDatabase,
+    IDBObjectStore,
+    IDBIndex,
+    IDBCursor,
+    IDBTransaction
+  ]);
+}
+function Fe() {
+  return W || (W = [
+    IDBCursor.prototype.advance,
+    IDBCursor.prototype.continue,
+    IDBCursor.prototype.continuePrimaryKey
+  ]);
+}
+const oe = /* @__PURE__ */ new WeakMap(), M = /* @__PURE__ */ new WeakMap(), ae = /* @__PURE__ */ new WeakMap(), B = /* @__PURE__ */ new WeakMap(), z = /* @__PURE__ */ new WeakMap();
+function ze(t) {
+  const e = new Promise((n, r) => {
+    const s = () => {
+      t.removeEventListener("success", i), t.removeEventListener("error", o);
+    }, i = () => {
+      n(u(t.result)), s();
+    }, o = () => {
+      r(t.error), s();
+    };
+    t.addEventListener("success", i), t.addEventListener("error", o);
+  });
+  return e.then((n) => {
+    n instanceof IDBCursor && oe.set(n, t);
+  }).catch(() => {
+  }), z.set(e, t), e;
+}
+function Ve(t) {
+  if (M.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);
+  });
+  M.set(t, e);
+}
+let $ = {
+  get(t, e, n) {
+    if (t instanceof IDBTransaction) {
+      if (e === "done")
+        return M.get(t);
+      if (e === "objectStoreNames")
+        return t.objectStoreNames || ae.get(t);
+      if (e === "store")
+        return n.objectStoreNames[1] ? void 0 : n.objectStore(n.objectStoreNames[0]);
+    }
+    return u(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 Ue(t) {
+  $ = t($);
+}
+function We(t) {
+  return t === IDBDatabase.prototype.transaction && !("objectStoreNames" in IDBTransaction.prototype) ? function(e, ...n) {
+    const r = t.call(T(this), e, ...n);
+    return ae.set(r, e.sort ? e.sort() : [e]), u(r);
+  } : Fe().includes(t) ? function(...e) {
+    return t.apply(T(this), e), u(oe.get(this));
+  } : function(...e) {
+    return u(t.apply(T(this), e));
+  };
+}
+function je(t) {
+  return typeof t == "function" ? We(t) : (t instanceof IDBTransaction && Ve(t), Pe(t, He()) ? new Proxy(t, $) : t);
+}
+function u(t) {
+  if (t instanceof IDBRequest)
+    return ze(t);
+  if (B.has(t))
+    return B.get(t);
+  const e = je(t);
+  return e !== t && (B.set(t, e), z.set(e, t)), e;
+}
+const T = (t) => z.get(t);
+function Ge(t, e, { blocked: n, upgrade: r, blocking: s, terminated: i } = {}) {
+  const o = indexedDB.open(t, e), c = u(o);
+  return r && o.addEventListener("upgradeneeded", (a) => {
+    r(u(o.result), a.oldVersion, a.newVersion, u(o.transaction), a);
+  }), n && o.addEventListener("blocked", (a) => n(
+    // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+    a.oldVersion,
+    a.newVersion,
+    a
+  )), c.then((a) => {
+    i && a.addEventListener("close", () => i()), s && a.addEventListener("versionchange", (f) => s(f.oldVersion, f.newVersion, f));
+  }).catch(() => {
+  }), c;
+}
+const Je = ["get", "getKey", "getAll", "getAllKeys", "count"], Ke = ["put", "add", "delete", "clear"], R = /* @__PURE__ */ new Map();
+function j(t, e) {
+  if (!(t instanceof IDBDatabase && !(e in t) && typeof e == "string"))
+    return;
+  if (R.get(e))
+    return R.get(e);
+  const n = e.replace(/FromIndex$/, ""), r = e !== n, s = Ke.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 || Je.includes(n))
+  )
+    return;
+  const i = async function(o, ...c) {
+    const a = this.transaction(o, s ? "readwrite" : "readonly");
+    let f = a.store;
+    return r && (f = f.index(c.shift())), (await Promise.all([
+      f[n](...c),
+      s && a.done
+    ]))[0];
+  };
+  return R.set(e, i), i;
+}
+Ue((t) => ({
+  ...t,
+  get: (e, n, r) => j(e, n) || t.get(e, n, r),
+  has: (e, n) => !!j(e, n) || t.has(e, n)
+}));
+class Ye {
+  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 (qe(n)) {
+        const r = n.getImmediate();
+        return `${r.library}/${r.version}`;
+      } else
+        return null;
+    }).filter((n) => n).join(" ");
+  }
+}
+function qe(t) {
+  return t.getComponent()?.type === "VERSION";
+}
+const S = "@firebase/app", L = "0.16.2";
+const d = new $e("@firebase/app"), Xe = "@firebase/app-compat", Qe = "@firebase/analytics-compat", Ze = "@firebase/analytics", et = "@firebase/app-check-compat", tt = "@firebase/app-check", nt = "@firebase/auth", rt = "@firebase/auth-compat", st = "@firebase/database", it = "@firebase/data-connect", ot = "@firebase/database-compat", at = "@firebase/functions", ct = "@firebase/functions-compat", lt = "@firebase/installations", ft = "@firebase/installations-compat", ht = "@firebase/messaging", dt = "@firebase/messaging-compat", ut = "@firebase/performance", pt = "@firebase/performance-compat", mt = "@firebase/remote-config", gt = "@firebase/remote-config-compat", bt = "@firebase/storage", yt = "@firebase/storage-compat", Et = "@firebase/firestore", _t = "@firebase/ai", vt = "@firebase/firestore-compat", wt = "firebase", Ct = "12.19.0";
+const A = "[DEFAULT]", Dt = {
+  [S]: "fire-core",
+  [Xe]: "fire-core-compat",
+  [Ze]: "fire-analytics",
+  [Qe]: "fire-analytics-compat",
+  [tt]: "fire-app-check",
+  [et]: "fire-app-check-compat",
+  [nt]: "fire-auth",
+  [rt]: "fire-auth-compat",
+  [st]: "fire-rtdb",
+  [it]: "fire-data-connect",
+  [ot]: "fire-rtdb-compat",
+  [at]: "fire-fn",
+  [ct]: "fire-fn-compat",
+  [lt]: "fire-iid",
+  [ft]: "fire-iid-compat",
+  [ht]: "fire-fcm",
+  [dt]: "fire-fcm-compat",
+  [ut]: "fire-perf",
+  [pt]: "fire-perf-compat",
+  [mt]: "fire-rc",
+  [gt]: "fire-rc-compat",
+  [bt]: "fire-gcs",
+  [yt]: "fire-gcs-compat",
+  [Et]: "fire-fst",
+  [vt]: "fire-fst-compat",
+  [_t]: "fire-vertex",
+  "fire-js": "fire-js",
+  // Platform identifier for JS SDK.
+  [wt]: "fire-js-all"
+};
+const g = /* @__PURE__ */ new Map(), E = /* @__PURE__ */ new Map(), _ = /* @__PURE__ */ new Map();
+function G(t, e) {
+  try {
+    t.container.addComponent(e);
+  } catch (n) {
+    d.debug(`Component ${e.name} failed to register with FirebaseApp ${t.name}`, n);
+  }
+}
+function nn(t, e) {
+  t.container.addOrOverwriteComponent(e);
+}
+function k(t) {
+  const e = t.name;
+  if (_.has(e))
+    return d.debug(`There were multiple attempts to register component ${e}.`), !1;
+  _.set(e, t);
+  for (const n of g.values())
+    G(n, t);
+  for (const n of E.values())
+    G(n, t);
+  return !0;
+}
+function It(t, e) {
+  const n = t.container.getProvider("heartbeat").getImmediate({ optional: !0 });
+  return n && n.triggerHeartbeat(), t.container.getProvider(e);
+}
+function rn(t, e, n = A) {
+  It(t, e).clearInstance(n);
+}
+function ce(t) {
+  return t.options !== void 0;
+}
+function St(t) {
+  return ce(t) ? !1 : "authIdToken" in t || "appCheckToken" in t || "releaseOnDeref" in t || "automaticDataCollectionEnabled" in t;
+}
+function sn(t) {
+  return t == null ? !1 : t.settings !== void 0;
+}
+function on() {
+  _.clear();
+}
+const At = {
+  "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 {$mismatchedParam}. Existing: '{$oldValue}'. New: '{$newValue}'.",
+  "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."
+}, h = new re("app", "Firebase", At);
+class le {
+  constructor(e, n, r) {
+    this._isDeleted = !1, this._options = { ...e }, this._config = { ...n }, this._name = n.name, this._automaticDataCollectionEnabled = n.automaticDataCollectionEnabled, this._container = r, this.container.addComponent(new I(
+      "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 h.create("app-deleted", { appName: this._name });
+  }
+}
+function J(t, e) {
+  const n = ee(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 Ot extends le {
+  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 c = e;
+      super(c.options, o, s);
+    }
+    this._serverConfig = {
+      automaticDataCollectionEnabled: i,
+      ...n
+    }, this._serverConfig.authIdToken && J(this._serverConfig.authIdToken, "authIdToken"), this._serverConfig.appCheckToken && J(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, D(S, L, "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() {
+    Tt(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 h.create(
+        "server-app-deleted"
+        /* AppError.SERVER_APP_DELETED */
+      );
+  }
+}
+const an = Ct;
+function Bt(t, e = {}) {
+  let n = t;
+  typeof e != "object" && (e = { name: e });
+  const r = {
+    name: A,
+    automaticDataCollectionEnabled: !0,
+    ...e
+  }, s = r.name;
+  if (typeof s != "string" || !s)
+    throw h.create("bad-app-name", {
+      appName: String(s)
+    });
+  if (n || (n = H()), !n)
+    throw h.create(
+      "no-options"
+      /* AppError.NO_OPTIONS */
+    );
+  const i = g.get(s);
+  if (i)
+    if (N(n, i.options)) {
+      if (N(r, i.config))
+        return i;
+      throw h.create("duplicate-app", {
+        appName: s,
+        mismatchedParam: "config",
+        oldValue: JSON.stringify(i.config),
+        newValue: JSON.stringify(r)
+      });
+    } else throw h.create("duplicate-app", {
+      appName: s,
+      mismatchedParam: "options",
+      oldValue: JSON.stringify(i.options),
+      newValue: JSON.stringify(n)
+    });
+  const o = new se(s);
+  for (const a of _.values())
+    o.addComponent(a);
+  const c = new le(n, r, o);
+  return g.set(s, c), c;
+}
+function cn(t, e = {}) {
+  if (we() && !ne())
+    throw h.create(
+      "invalid-server-app-environment"
+      /* AppError.INVALID_SERVER_APP_ENVIRONMENT */
+    );
+  let n, r = e || {};
+  if (t && (ce(t) ? n = t.options : St(t) ? r = t : n = t), r.automaticDataCollectionEnabled === void 0 && (r.automaticDataCollectionEnabled = !0), n || (n = H()), !n)
+    throw h.create(
+      "no-options"
+      /* AppError.NO_OPTIONS */
+    );
+  const s = {
+    ...r,
+    ...n
+  };
+  s.releaseOnDeref !== void 0 && delete s.releaseOnDeref;
+  const i = (b) => [...b].reduce((p, y) => Math.imul(31, p) + y.charCodeAt(0) | 0, 0);
+  if (r.releaseOnDeref !== void 0 && typeof FinalizationRegistry > "u")
+    throw h.create("finalization-registry-not-supported", {});
+  const o = "" + i(JSON.stringify(s)), c = E.get(o);
+  if (c)
+    return c.incRefCount(r.releaseOnDeref), c;
+  const a = new se(o);
+  for (const b of _.values())
+    a.addComponent(b);
+  const f = new Ot(n, r, o, a);
+  return E.set(o, f), f;
+}
+function ln(t = A) {
+  const e = g.get(t);
+  if (!e && t === A && H())
+    return Bt();
+  if (!e)
+    throw h.create("no-app", { appName: t });
+  return e;
+}
+function fn() {
+  return Array.from(g.values());
+}
+async function Tt(t) {
+  let e = !1;
+  const n = t.name;
+  g.has(n) ? (e = !0, g.delete(n)) : E.has(n) && t.decRefCount() <= 0 && (E.delete(n), e = !0), e && (await Promise.all(t.container.getProviders().map((r) => r.delete())), t.isDeleted = !0);
+}
+function D(t, e, n) {
+  let r = Dt[t] ?? t;
+  n && (r += `-${n}`);
+  const s = r.match(/\s|\//), i = e.match(/\s|\//);
+  if (s || i) {
+    const o = [
+      `Unable to register library "${r}" with version "${e}":`
+    ];
+    s && o.push(`library name "${r}" contains illegal characters (whitespace or "/")`), s && i && o.push("and"), i && o.push(`version name "${e}" contains illegal characters (whitespace or "/")`), d.warn(o.join(" "));
+    return;
+  }
+  k(new I(
+    `${r}-version`,
+    () => ({ library: r, version: e }),
+    "VERSION"
+    /* ComponentType.VERSION */
+  ));
+}
+function hn(t, e) {
+  if (t !== null && typeof t != "function")
+    throw h.create(
+      "invalid-log-argument"
+      /* AppError.INVALID_LOG_ARGUMENT */
+    );
+  ke(t, e);
+}
+function dn(t) {
+  Le(t);
+}
+const Rt = "firebase-heartbeat-database", xt = 1, v = "firebase-heartbeat-store";
+let x = null;
+function fe() {
+  return x || (x = Ge(Rt, xt, {
+    upgrade: (t, e) => {
+      switch (e) {
+        case 0:
+          try {
+            t.createObjectStore(v);
+          } catch (n) {
+            console.warn(n);
+          }
+      }
+    }
+  }).catch((t) => {
+    throw h.create("idb-open", {
+      originalErrorMessage: t.message
+    });
+  })), x;
+}
+async function Nt(t) {
+  try {
+    const n = (await fe()).transaction(v), r = await n.objectStore(v).get(he(t));
+    return await n.done, r;
+  } catch (e) {
+    if (e instanceof w)
+      d.warn(e.message);
+    else {
+      const n = h.create("idb-get", {
+        originalErrorMessage: e?.message
+      });
+      d.warn(n.message);
+    }
+  }
+}
+async function K(t, e) {
+  try {
+    const r = (await fe()).transaction(v, "readwrite");
+    await r.objectStore(v).put(e, he(t)), await r.done;
+  } catch (n) {
+    if (n instanceof w)
+      d.warn(n.message);
+    else {
+      const r = h.create("idb-set", {
+        originalErrorMessage: n?.message
+      });
+      d.warn(r.message);
+    }
+  }
+}
+function he(t) {
+  return `${t.name}!${t.options.appId}`;
+}
+const Mt = 1024, $t = 30;
+class Lt {
+  constructor(e) {
+    this.container = e, this._heartbeatsCache = null;
+    const n = this.container.getProvider("app").getImmediate();
+    this._storage = new Pt(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() {
+    try {
+      const n = this.container.getProvider("platform-logger").getImmediate().getPlatformInfoString(), r = Y();
+      if (this._heartbeatsCache?.heartbeats == null && (this._heartbeatsCache = await this._heartbeatsCachePromise, this._heartbeatsCache?.heartbeats == null) || this._heartbeatsCache.lastSentHeartbeatDate === r || this._heartbeatsCache.heartbeats.some((s) => s.date === r))
+        return;
+      if (this._heartbeatsCache.heartbeats.push({ date: r, agent: n }), this._heartbeatsCache.heartbeats.length > $t) {
+        const s = Ht(this._heartbeatsCache.heartbeats);
+        this._heartbeatsCache.heartbeats.splice(s, 1);
+      }
+      return this._storage.overwrite(this._heartbeatsCache);
+    } catch (e) {
+      d.warn(e);
+    }
+  }
+  /**
+   * 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() {
+    try {
+      if (this._heartbeatsCache === null && await this._heartbeatsCachePromise, this._heartbeatsCache?.heartbeats == null || this._heartbeatsCache.heartbeats.length === 0)
+        return "";
+      const e = Y(), { heartbeatsToSend: n, unsentEntries: r } = kt(this._heartbeatsCache.heartbeats), s = Z(JSON.stringify({ version: 2, heartbeats: n }));
+      return this._heartbeatsCache.lastSentHeartbeatDate = e, r.length > 0 ? (this._heartbeatsCache.heartbeats = r, await this._storage.overwrite(this._heartbeatsCache)) : (this._heartbeatsCache.heartbeats = [], this._storage.overwrite(this._heartbeatsCache)), s;
+    } catch (e) {
+      return d.warn(e), "";
+    }
+  }
+}
+function Y() {
+  return (/* @__PURE__ */ new Date()).toISOString().substring(0, 10);
+}
+function kt(t, e = Mt) {
+  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), q(n) > e) {
+        i.dates.pop();
+        break;
+      }
+    } else if (n.push({
+      agent: s.agent,
+      dates: [s.date]
+    }), q(n) > e) {
+      n.pop();
+      break;
+    }
+    r = r.slice(1);
+  }
+  return {
+    heartbeatsToSend: n,
+    unsentEntries: r
+  };
+}
+class Pt {
+  constructor(e) {
+    this.app = e, this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();
+  }
+  async runIndexedDBEnvironmentCheck() {
+    return Ce() ? De().then(() => !0).catch(() => !1) : !1;
+  }
+  /**
+   * Read all heartbeats.
+   */
+  async read() {
+    if (await this._canUseIndexedDBPromise) {
+      const n = await Nt(this.app);
+      return n?.heartbeats ? n : { heartbeats: [] };
+    } else
+      return { heartbeats: [] };
+  }
+  // overwrite the storage with the provided heartbeats
+  async overwrite(e) {
+    if (await this._canUseIndexedDBPromise) {
+      const r = await this.read();
+      return K(this.app, {
+        lastSentHeartbeatDate: e.lastSentHeartbeatDate ?? r.lastSentHeartbeatDate,
+        heartbeats: e.heartbeats
+      });
+    } else
+      return;
+  }
+  // add heartbeats
+  async add(e) {
+    if (await this._canUseIndexedDBPromise) {
+      const r = await this.read();
+      return K(this.app, {
+        lastSentHeartbeatDate: e.lastSentHeartbeatDate ?? r.lastSentHeartbeatDate,
+        heartbeats: [
+          ...r.heartbeats,
+          ...e.heartbeats
+        ]
+      });
+    } else
+      return;
+  }
+}
+function q(t) {
+  return Z(
+    // heartbeatsCache wrapper properties
+    JSON.stringify({ version: 2, heartbeats: t })
+  ).length;
+}
+function Ht(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 Ft(t) {
+  k(new I(
+    "platform-logger",
+    (e) => new Ye(e),
+    "PRIVATE"
+    /* ComponentType.PRIVATE */
+  )), k(new I(
+    "heartbeat",
+    (e) => new Lt(e),
+    "PRIVATE"
+    /* ComponentType.PRIVATE */
+  )), D(S, L, t), D(S, L, "esm2020"), D("fire-js", "");
+}
+Ft("");
+export {
+  Vt as A,
+  zt as B,
+  te as C,
+  A as D,
+  Jt as E,
+  w as F,
+  Kt as G,
+  ee as H,
+  l as I,
+  re as J,
+  Ut as K,
+  $e as L,
+  Gt as M,
+  ve as N,
+  jt as O,
+  Wt as P,
+  I as Q,
+  Qt as R,
+  an as S,
+  G as _,
+  nn as a,
+  g as b,
+  on as c,
+  _ as d,
+  It as e,
+  ce as f,
+  sn as g,
+  St as h,
+  k as i,
+  rn as j,
+  E as k,
+  Tt as l,
+  ln as m,
+  fn as n,
+  Bt as o,
+  cn as p,
+  hn as q,
+  D as r,
+  dn as s,
+  qt as t,
+  Xt as u,
+  Yt as v,
+  Zt as w,
+  N as x,
+  en as y,
+  tn as z
+};