@feedmepos/mf-settings 0.0.48-beta.0-ex → 0.0.48-beta.1

package/dist/index.esm2017-c60b1ce5.js

@@ -0,0 +1,3147 @@
+import { ref as ot } from "vue";
+const oe = ot(null), Zr = () => oe.value;
+function Qr(t) {
+  oe.value || (oe.value = t);
+}
+const es = Object.freeze({
+  jb: {
+    lat: 1.492659,
+    lng: 103.7413591
+  }
+});
+function ts(t) {
+  return [t.lng, t.lat];
+}
+function ns(t) {
+  if (t.length !== 2)
+    throw Error("Invalid coordinate array");
+  return {
+    lat: t[1],
+    lng: t[0]
+  };
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const Be = function(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;
+}, it = 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 o = t[n++];
+      e[r++] = String.fromCharCode((s & 31) << 6 | o & 63);
+    } else if (s > 239 && s < 365) {
+      const o = t[n++], i = t[n++], a = t[n++], c = ((s & 7) << 18 | (o & 63) << 12 | (i & 63) << 6 | a & 63) - 65536;
+      e[r++] = String.fromCharCode(55296 + (c >> 10)), e[r++] = String.fromCharCode(56320 + (c & 1023));
+    } else {
+      const o = t[n++], i = t[n++];
+      e[r++] = String.fromCharCode((s & 15) << 12 | (o & 63) << 6 | i & 63);
+    }
+  }
+  return e.join("");
+}, xe = {
+  /**
+   * Maps bytes to characters.
+   */
+  byteToCharMap_: null,
+  /**
+   * Maps characters to bytes.
+   */
+  charToByteMap_: null,
+  /**
+   * Maps bytes to websafe characters.
+   * @private
+   */
+  byteToCharMapWebSafe_: null,
+  /**
+   * Maps websafe characters to bytes.
+   * @private
+   */
+  charToByteMapWebSafe_: null,
+  /**
+   * Our default alphabet, shared between
+   * ENCODED_VALS and ENCODED_VALS_WEBSAFE
+   */
+  ENCODED_VALS_BASE: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
+  /**
+   * Our default alphabet. Value 64 (=) is special; it means "nothing."
+   */
+  get ENCODED_VALS() {
+    return this.ENCODED_VALS_BASE + "+/=";
+  },
+  /**
+   * Our websafe alphabet.
+   */
+  get ENCODED_VALS_WEBSAFE() {
+    return this.ENCODED_VALS_BASE + "-_.";
+  },
+  /**
+   * Whether this browser supports the atob and btoa functions. This extension
+   * started at Mozilla but is now implemented by many browsers. We use the
+   * ASSUME_* variables to avoid pulling in the full useragent detection library
+   * but still allowing the standard per-browser compilations.
+   *
+   */
+  HAS_NATIVE_SUPPORT: typeof atob == "function",
+  /**
+   * Base64-encode an array of bytes.
+   *
+   * @param input An array of bytes (numbers with
+   *     value in [0, 255]) to encode.
+   * @param webSafe Boolean indicating we should use the
+   *     alternative alphabet.
+   * @return The base64 encoded string.
+   */
+  encodeByteArray(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 o = t[s], i = s + 1 < t.length, a = i ? t[s + 1] : 0, c = s + 2 < t.length, l = c ? t[s + 2] : 0, g = o >> 2, f = (o & 3) << 4 | a >> 4;
+      let p = (a & 15) << 2 | l >> 6, m = l & 63;
+      c || (m = 64, i || (p = 64)), r.push(n[g], n[f], n[p], n[m]);
+    }
+    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(Be(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) : it(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 o = n[t.charAt(s++)], a = s < t.length ? n[t.charAt(s)] : 0;
+      ++s;
+      const l = s < t.length ? n[t.charAt(s)] : 64;
+      ++s;
+      const f = s < t.length ? n[t.charAt(s)] : 64;
+      if (++s, o == null || a == null || l == null || f == null)
+        throw new at();
+      const p = o << 2 | a >> 4;
+      if (r.push(p), l !== 64) {
+        const m = a << 4 & 240 | l >> 2;
+        if (r.push(m), f !== 64) {
+          const w = l << 6 & 192 | f;
+          r.push(w);
+        }
+      }
+    }
+    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 at extends Error {
+  constructor() {
+    super(...arguments), this.name = "DecodeBase64StringError";
+  }
+}
+const ct = function(t) {
+  const e = Be(t);
+  return xe.encodeByteArray(e, !0);
+}, q = function(t) {
+  return ct(t).replace(/\./g, "");
+}, lt = function(t) {
+  try {
+    return xe.decodeString(t, !0);
+  } catch (e) {
+    console.error("base64Decode failed: ", e);
+  }
+  return null;
+};
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function ut() {
+  if (typeof self < "u")
+    return self;
+  if (typeof window < "u")
+    return window;
+  if (typeof global < "u")
+    return global;
+  throw new Error("Unable to locate global object.");
+}
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const ht = () => ut().__FIREBASE_DEFAULTS__, dt = () => {
+  if (typeof process > "u" || typeof process.env > "u")
+    return;
+  const t = process.env.__FIREBASE_DEFAULTS__;
+  if (t)
+    return JSON.parse(t);
+}, ft = () => {
+  if (typeof document > "u")
+    return;
+  let t;
+  try {
+    t = document.cookie.match(/__FIREBASE_DEFAULTS__=([^;]+)/);
+  } catch {
+    return;
+  }
+  const e = t && lt(t[1]);
+  return e && JSON.parse(e);
+}, K = () => {
+  try {
+    return ht() || dt() || ft();
+  } catch (t) {
+    console.info(`Unable to get __FIREBASE_DEFAULTS__ due to: ${t}`);
+    return;
+  }
+}, pt = (t) => {
+  var e, n;
+  return (n = (e = K()) === null || e === void 0 ? void 0 : e.emulatorHosts) === null || n === void 0 ? void 0 : n[t];
+}, gt = (t) => {
+  const e = pt(t);
+  if (!e)
+    return;
+  const n = e.lastIndexOf(":");
+  if (n <= 0 || n + 1 === e.length)
+    throw new Error(`Invalid host ${e} with no separate hostname and port!`);
+  const r = parseInt(e.substring(n + 1), 10);
+  return e[0] === "[" ? [e.substring(1, n - 1), r] : [e.substring(0, n), r];
+}, Ue = () => {
+  var t;
+  return (t = K()) === null || t === void 0 ? void 0 : t.config;
+}, rs = (t) => {
+  var e;
+  return (e = K()) === null || e === void 0 ? void 0 : e[`_${t}`];
+};
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class mt {
+  constructor() {
+    this.reject = () => {
+    }, this.resolve = () => {
+    }, this.promise = new Promise((e, n) => {
+      this.resolve = e, this.reject = n;
+    });
+  }
+  /**
+   * Our API internals are not promiseified 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));
+    };
+  }
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _t(t, e) {
+  if (t.uid)
+    throw new Error('The "uid" field is no longer supported by mockUserToken. Please use "sub" instead for Firebase Auth User ID.');
+  const n = {
+    alg: "none",
+    type: "JWT"
+  }, r = e || "demo-project", s = t.iat || 0, o = t.sub || t.user_id;
+  if (!o)
+    throw new Error("mockUserToken must contain 'sub' or 'user_id' field!");
+  const i = Object.assign({
+    // Set all required fields to decent defaults
+    iss: `https://securetoken.google.com/${r}`,
+    aud: r,
+    iat: s,
+    exp: s + 3600,
+    auth_time: s,
+    sub: o,
+    user_id: o,
+    firebase: {
+      sign_in_provider: "custom",
+      identities: {}
+    }
+  }, t), a = "";
+  return [
+    q(JSON.stringify(n)),
+    q(JSON.stringify(i)),
+    a
+  ].join(".");
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function Pe() {
+  return typeof navigator < "u" && typeof navigator.userAgent == "string" ? navigator.userAgent : "";
+}
+function ss() {
+  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(Pe());
+}
+function bt() {
+  var t;
+  const e = (t = K()) === null || t === void 0 ? void 0 : t.forceEnvironment;
+  if (e === "node")
+    return !0;
+  if (e === "browser")
+    return !1;
+  try {
+    return Object.prototype.toString.call(global.process) === "[object process]";
+  } catch {
+    return !1;
+  }
+}
+function os() {
+  const t = typeof chrome == "object" ? chrome.runtime : typeof browser == "object" ? browser.runtime : void 0;
+  return typeof t == "object" && t.id !== void 0;
+}
+function is() {
+  return typeof navigator == "object" && navigator.product === "ReactNative";
+}
+function as() {
+  const t = Pe();
+  return t.indexOf("MSIE ") >= 0 || t.indexOf("Trident/") >= 0;
+}
+function yt() {
+  try {
+    return typeof indexedDB == "object";
+  } catch {
+    return !1;
+  }
+}
+function Et() {
+  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 o;
+        e(((o = s.error) === null || o === void 0 ? void 0 : o.message) || "");
+      };
+    } catch (n) {
+      e(n);
+    }
+  });
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const wt = "FirebaseError";
+class x extends Error {
+  constructor(e, n, r) {
+    super(n), this.code = e, this.customData = r, this.name = wt, Object.setPrototypeOf(this, x.prototype), Error.captureStackTrace && Error.captureStackTrace(this, Le.prototype.create);
+  }
+}
+class Le {
+  constructor(e, n, r) {
+    this.service = e, this.serviceName = n, this.errors = r;
+  }
+  create(e, ...n) {
+    const r = n[0] || {}, s = `${this.service}/${e}`, o = this.errors[e], i = o ? It(o, r) : "Error", a = `${this.serviceName}: ${i} (${s}).`;
+    return new x(s, a, r);
+  }
+}
+function It(t, e) {
+  return t.replace(Rt, (n, r) => {
+    const s = e[r];
+    return s != null ? String(s) : `<${r}?>`;
+  });
+}
+const Rt = /\{\$([^}]+)}/g;
+function cs(t) {
+  for (const e in t)
+    if (Object.prototype.hasOwnProperty.call(t, e))
+      return !1;
+  return !0;
+}
+function ie(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 o = t[s], i = e[s];
+    if (Ee(o) && Ee(i)) {
+      if (!ie(o, i))
+        return !1;
+    } else if (o !== i)
+      return !1;
+  }
+  for (const s of r)
+    if (!n.includes(s))
+      return !1;
+  return !0;
+}
+function Ee(t) {
+  return t !== null && typeof t == "object";
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function ls(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 us(t, e) {
+  const n = new Tt(t, e);
+  return n.subscribe.bind(n);
+}
+class Tt {
+  /**
+   * @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 sychronously 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.");
+    At(e, [
+      "next",
+      "error",
+      "complete"
+    ]) ? s = e : s = {
+      next: e,
+      error: n,
+      complete: r
+    }, s.next === void 0 && (s.next = Z), s.error === void 0 && (s.error = Z), s.complete === void 0 && (s.complete = Z);
+    const o = 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), o;
+  }
+  // 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 At(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 Z() {
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function U(t) {
+  return t && t._delegate ? t._delegate : t;
+}
+class $ {
+  /**
+   *
+   * @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;
+  }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const C = "[DEFAULT]";
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class vt {
+  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 mulitple 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 mt();
+      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 == null ? void 0 : e.identifier), s = (n = e == null ? void 0 : e.optional) !== null && n !== void 0 ? n : !1;
+    if (this.isInitialized(r) || this.shouldAutoInitialize())
+      try {
+        return this.getOrInitializeService({
+          instanceIdentifier: r
+        });
+      } catch (o) {
+        if (s)
+          return null;
+        throw o;
+      }
+    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 (Ct(e))
+        try {
+          this.getOrInitializeService({ instanceIdentifier: C });
+        } catch {
+        }
+      for (const [n, r] of this.instancesDeferred.entries()) {
+        const s = this.normalizeInstanceIdentifier(n);
+        try {
+          const o = this.getOrInitializeService({
+            instanceIdentifier: s
+          });
+          r.resolve(o);
+        } catch {
+        }
+      }
+    }
+  }
+  clearInstance(e = C) {
+    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 = C) {
+    return this.instances.has(e);
+  }
+  getOptions(e = C) {
+    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 [o, i] of this.instancesDeferred.entries()) {
+      const a = this.normalizeInstanceIdentifier(o);
+      r === a && i.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), o = (r = this.onInitCallbacks.get(s)) !== null && r !== void 0 ? r : /* @__PURE__ */ new Set();
+    o.add(e), this.onInitCallbacks.set(s, o);
+    const i = this.instances.get(s);
+    return i && e(i, s), () => {
+      o.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: Dt(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 = C) {
+    return this.component ? this.component.multipleInstances ? e : C : e;
+  }
+  shouldAutoInitialize() {
+    return !!this.component && this.component.instantiationMode !== "EXPLICIT";
+  }
+}
+function Dt(t) {
+  return t === C ? void 0 : t;
+}
+function Ct(t) {
+  return t.instantiationMode === "EAGER";
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Ot {
+  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 vt(e, this);
+    return this.providers.set(e, n), n;
+  }
+  getProviders() {
+    return Array.from(this.providers.values());
+  }
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var u;
+(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";
+})(u || (u = {}));
+const St = {
+  debug: u.DEBUG,
+  verbose: u.VERBOSE,
+  info: u.INFO,
+  warn: u.WARN,
+  error: u.ERROR,
+  silent: u.SILENT
+}, Nt = u.INFO, kt = {
+  [u.DEBUG]: "log",
+  [u.VERBOSE]: "log",
+  [u.INFO]: "info",
+  [u.WARN]: "warn",
+  [u.ERROR]: "error"
+}, Bt = (t, e, ...n) => {
+  if (e < t.logLevel)
+    return;
+  const r = (/* @__PURE__ */ new Date()).toISOString(), s = kt[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 xt {
+  /**
+   * 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 = Nt, this._logHandler = Bt, this._userLogHandler = null;
+  }
+  get logLevel() {
+    return this._logLevel;
+  }
+  set logLevel(e) {
+    if (!(e in u))
+      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" ? St[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, u.DEBUG, ...e), this._logHandler(this, u.DEBUG, ...e);
+  }
+  log(...e) {
+    this._userLogHandler && this._userLogHandler(this, u.VERBOSE, ...e), this._logHandler(this, u.VERBOSE, ...e);
+  }
+  info(...e) {
+    this._userLogHandler && this._userLogHandler(this, u.INFO, ...e), this._logHandler(this, u.INFO, ...e);
+  }
+  warn(...e) {
+    this._userLogHandler && this._userLogHandler(this, u.WARN, ...e), this._logHandler(this, u.WARN, ...e);
+  }
+  error(...e) {
+    this._userLogHandler && this._userLogHandler(this, u.ERROR, ...e), this._logHandler(this, u.ERROR, ...e);
+  }
+}
+const Ut = (t, e) => e.some((n) => t instanceof n);
+let we, Ie;
+function Pt() {
+  return we || (we = [
+    IDBDatabase,
+    IDBObjectStore,
+    IDBIndex,
+    IDBCursor,
+    IDBTransaction
+  ]);
+}
+function Lt() {
+  return Ie || (Ie = [
+    IDBCursor.prototype.advance,
+    IDBCursor.prototype.continue,
+    IDBCursor.prototype.continuePrimaryKey
+  ]);
+}
+const Me = /* @__PURE__ */ new WeakMap(), ae = /* @__PURE__ */ new WeakMap(), $e = /* @__PURE__ */ new WeakMap(), Q = /* @__PURE__ */ new WeakMap(), fe = /* @__PURE__ */ new WeakMap();
+function Mt(t) {
+  const e = new Promise((n, r) => {
+    const s = () => {
+      t.removeEventListener("success", o), t.removeEventListener("error", i);
+    }, o = () => {
+      n(A(t.result)), s();
+    }, i = () => {
+      r(t.error), s();
+    };
+    t.addEventListener("success", o), t.addEventListener("error", i);
+  });
+  return e.then((n) => {
+    n instanceof IDBCursor && Me.set(n, t);
+  }).catch(() => {
+  }), fe.set(e, t), e;
+}
+function $t(t) {
+  if (ae.has(t))
+    return;
+  const e = new Promise((n, r) => {
+    const s = () => {
+      t.removeEventListener("complete", o), t.removeEventListener("error", i), t.removeEventListener("abort", i);
+    }, o = () => {
+      n(), s();
+    }, i = () => {
+      r(t.error || new DOMException("AbortError", "AbortError")), s();
+    };
+    t.addEventListener("complete", o), t.addEventListener("error", i), t.addEventListener("abort", i);
+  });
+  ae.set(t, e);
+}
+let ce = {
+  get(t, e, n) {
+    if (t instanceof IDBTransaction) {
+      if (e === "done")
+        return ae.get(t);
+      if (e === "objectStoreNames")
+        return t.objectStoreNames || $e.get(t);
+      if (e === "store")
+        return n.objectStoreNames[1] ? void 0 : n.objectStore(n.objectStoreNames[0]);
+    }
+    return A(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 Ft(t) {
+  ce = t(ce);
+}
+function Ht(t) {
+  return t === IDBDatabase.prototype.transaction && !("objectStoreNames" in IDBTransaction.prototype) ? function(e, ...n) {
+    const r = t.call(ee(this), e, ...n);
+    return $e.set(r, e.sort ? e.sort() : [e]), A(r);
+  } : Lt().includes(t) ? function(...e) {
+    return t.apply(ee(this), e), A(Me.get(this));
+  } : function(...e) {
+    return A(t.apply(ee(this), e));
+  };
+}
+function jt(t) {
+  return typeof t == "function" ? Ht(t) : (t instanceof IDBTransaction && $t(t), Ut(t, Pt()) ? new Proxy(t, ce) : t);
+}
+function A(t) {
+  if (t instanceof IDBRequest)
+    return Mt(t);
+  if (Q.has(t))
+    return Q.get(t);
+  const e = jt(t);
+  return e !== t && (Q.set(t, e), fe.set(e, t)), e;
+}
+const ee = (t) => fe.get(t);
+function Vt(t, e, { blocked: n, upgrade: r, blocking: s, terminated: o } = {}) {
+  const i = indexedDB.open(t, e), a = A(i);
+  return r && i.addEventListener("upgradeneeded", (c) => {
+    r(A(i.result), c.oldVersion, c.newVersion, A(i.transaction), c);
+  }), n && i.addEventListener("blocked", (c) => n(
+    // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+    c.oldVersion,
+    c.newVersion,
+    c
+  )), a.then((c) => {
+    o && c.addEventListener("close", () => o()), s && c.addEventListener("versionchange", (l) => s(l.oldVersion, l.newVersion, l));
+  }).catch(() => {
+  }), a;
+}
+const zt = ["get", "getKey", "getAll", "getAllKeys", "count"], Wt = ["put", "add", "delete", "clear"], te = /* @__PURE__ */ new Map();
+function Re(t, e) {
+  if (!(t instanceof IDBDatabase && !(e in t) && typeof e == "string"))
+    return;
+  if (te.get(e))
+    return te.get(e);
+  const n = e.replace(/FromIndex$/, ""), r = e !== n, s = Wt.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 || zt.includes(n))
+  )
+    return;
+  const o = async function(i, ...a) {
+    const c = this.transaction(i, s ? "readwrite" : "readonly");
+    let l = c.store;
+    return r && (l = l.index(a.shift())), (await Promise.all([
+      l[n](...a),
+      s && c.done
+    ]))[0];
+  };
+  return te.set(e, o), o;
+}
+Ft((t) => ({
+  ...t,
+  get: (e, n, r) => Re(e, n) || t.get(e, n, r),
+  has: (e, n) => !!Re(e, n) || t.has(e, n)
+}));
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class qt {
+  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 (Gt(n)) {
+        const r = n.getImmediate();
+        return `${r.library}/${r.version}`;
+      } else
+        return null;
+    }).filter((n) => n).join(" ");
+  }
+}
+function Gt(t) {
+  const e = t.getComponent();
+  return (e == null ? void 0 : e.type) === "VERSION";
+}
+const le = "@firebase/app", Te = "0.9.13";
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const S = new xt("@firebase/app"), Kt = "@firebase/app-compat", Xt = "@firebase/analytics-compat", Jt = "@firebase/analytics", Yt = "@firebase/app-check-compat", Zt = "@firebase/app-check", Qt = "@firebase/auth", en = "@firebase/auth-compat", tn = "@firebase/database", nn = "@firebase/database-compat", rn = "@firebase/functions", sn = "@firebase/functions-compat", on = "@firebase/installations", an = "@firebase/installations-compat", cn = "@firebase/messaging", ln = "@firebase/messaging-compat", un = "@firebase/performance", hn = "@firebase/performance-compat", dn = "@firebase/remote-config", fn = "@firebase/remote-config-compat", pn = "@firebase/storage", gn = "@firebase/storage-compat", mn = "@firebase/firestore", _n = "@firebase/firestore-compat", bn = "firebase", yn = "9.23.0";
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const ue = "[DEFAULT]", En = {
+  [le]: "fire-core",
+  [Kt]: "fire-core-compat",
+  [Jt]: "fire-analytics",
+  [Xt]: "fire-analytics-compat",
+  [Zt]: "fire-app-check",
+  [Yt]: "fire-app-check-compat",
+  [Qt]: "fire-auth",
+  [en]: "fire-auth-compat",
+  [tn]: "fire-rtdb",
+  [nn]: "fire-rtdb-compat",
+  [rn]: "fire-fn",
+  [sn]: "fire-fn-compat",
+  [on]: "fire-iid",
+  [an]: "fire-iid-compat",
+  [cn]: "fire-fcm",
+  [ln]: "fire-fcm-compat",
+  [un]: "fire-perf",
+  [hn]: "fire-perf-compat",
+  [dn]: "fire-rc",
+  [fn]: "fire-rc-compat",
+  [pn]: "fire-gcs",
+  [gn]: "fire-gcs-compat",
+  [mn]: "fire-fst",
+  [_n]: "fire-fst-compat",
+  "fire-js": "fire-js",
+  [bn]: "fire-js-all"
+};
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const F = /* @__PURE__ */ new Map(), he = /* @__PURE__ */ new Map();
+function wn(t, e) {
+  try {
+    t.container.addComponent(e);
+  } catch (n) {
+    S.debug(`Component ${e.name} failed to register with FirebaseApp ${t.name}`, n);
+  }
+}
+function G(t) {
+  const e = t.name;
+  if (he.has(e))
+    return S.debug(`There were multiple attempts to register component ${e}.`), !1;
+  he.set(e, t);
+  for (const n of F.values())
+    wn(n, t);
+  return !0;
+}
+function In(t, e) {
+  const n = t.container.getProvider("heartbeat").getImmediate({ optional: !0 });
+  return n && n.triggerHeartbeat(), t.container.getProvider(e);
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const Rn = {
+  "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",
+  "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}."
+}, v = new Le("app", "Firebase", Rn);
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Tn {
+  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 $(
+      "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 v.create("app-deleted", { appName: this._name });
+  }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const An = yn;
+function vn(t, e = {}) {
+  let n = t;
+  typeof e != "object" && (e = { name: e });
+  const r = Object.assign({ name: ue, automaticDataCollectionEnabled: !1 }, e), s = r.name;
+  if (typeof s != "string" || !s)
+    throw v.create("bad-app-name", {
+      appName: String(s)
+    });
+  if (n || (n = Ue()), !n)
+    throw v.create(
+      "no-options"
+      /* AppError.NO_OPTIONS */
+    );
+  const o = F.get(s);
+  if (o) {
+    if (ie(n, o.options) && ie(r, o.config))
+      return o;
+    throw v.create("duplicate-app", { appName: s });
+  }
+  const i = new Ot(s);
+  for (const c of he.values())
+    i.addComponent(c);
+  const a = new Tn(n, r, i);
+  return F.set(s, a), a;
+}
+function Dn(t = ue) {
+  const e = F.get(t);
+  if (!e && t === ue && Ue())
+    return vn();
+  if (!e)
+    throw v.create("no-app", { appName: t });
+  return e;
+}
+function hs() {
+  return Array.from(F.values());
+}
+function L(t, e, n) {
+  var r;
+  let s = (r = En[t]) !== null && r !== void 0 ? r : t;
+  n && (s += `-${n}`);
+  const o = s.match(/\s|\//), i = e.match(/\s|\//);
+  if (o || i) {
+    const a = [
+      `Unable to register library "${s}" with version "${e}":`
+    ];
+    o && a.push(`library name "${s}" contains illegal characters (whitespace or "/")`), o && i && a.push("and"), i && a.push(`version name "${e}" contains illegal characters (whitespace or "/")`), S.warn(a.join(" "));
+    return;
+  }
+  G(new $(
+    `${s}-version`,
+    () => ({ library: s, version: e }),
+    "VERSION"
+    /* ComponentType.VERSION */
+  ));
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const Cn = "firebase-heartbeat-database", On = 1, H = "firebase-heartbeat-store";
+let ne = null;
+function Fe() {
+  return ne || (ne = Vt(Cn, On, {
+    upgrade: (t, e) => {
+      switch (e) {
+        case 0:
+          t.createObjectStore(H);
+      }
+    }
+  }).catch((t) => {
+    throw v.create("idb-open", {
+      originalErrorMessage: t.message
+    });
+  })), ne;
+}
+async function Sn(t) {
+  try {
+    return await (await Fe()).transaction(H).objectStore(H).get(He(t));
+  } catch (e) {
+    if (e instanceof x)
+      S.warn(e.message);
+    else {
+      const n = v.create("idb-get", {
+        originalErrorMessage: e == null ? void 0 : e.message
+      });
+      S.warn(n.message);
+    }
+  }
+}
+async function Ae(t, e) {
+  try {
+    const r = (await Fe()).transaction(H, "readwrite");
+    await r.objectStore(H).put(e, He(t)), await r.done;
+  } catch (n) {
+    if (n instanceof x)
+      S.warn(n.message);
+    else {
+      const r = v.create("idb-set", {
+        originalErrorMessage: n == null ? void 0 : n.message
+      });
+      S.warn(r.message);
+    }
+  }
+}
+function He(t) {
+  return `${t.name}!${t.options.appId}`;
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const Nn = 1024, kn = 30 * 24 * 60 * 60 * 1e3;
+class Bn {
+  constructor(e) {
+    this.container = e, this._heartbeatsCache = null;
+    const n = this.container.getProvider("app").getImmediate();
+    this._storage = new Un(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() {
+    const n = this.container.getProvider("platform-logger").getImmediate().getPlatformInfoString(), r = ve();
+    if (this._heartbeatsCache === null && (this._heartbeatsCache = await this._heartbeatsCachePromise), !(this._heartbeatsCache.lastSentHeartbeatDate === r || this._heartbeatsCache.heartbeats.some((s) => s.date === r)))
+      return this._heartbeatsCache.heartbeats.push({ date: r, agent: n }), this._heartbeatsCache.heartbeats = this._heartbeatsCache.heartbeats.filter((s) => {
+        const o = new Date(s.date).valueOf();
+        return Date.now() - o <= kn;
+      }), this._storage.overwrite(this._heartbeatsCache);
+  }
+  /**
+   * 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() {
+    if (this._heartbeatsCache === null && await this._heartbeatsCachePromise, this._heartbeatsCache === null || this._heartbeatsCache.heartbeats.length === 0)
+      return "";
+    const e = ve(), { heartbeatsToSend: n, unsentEntries: r } = xn(this._heartbeatsCache.heartbeats), s = q(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;
+  }
+}
+function ve() {
+  return (/* @__PURE__ */ new Date()).toISOString().substring(0, 10);
+}
+function xn(t, e = Nn) {
+  const n = [];
+  let r = t.slice();
+  for (const s of t) {
+    const o = n.find((i) => i.agent === s.agent);
+    if (o) {
+      if (o.dates.push(s.date), De(n) > e) {
+        o.dates.pop();
+        break;
+      }
+    } else if (n.push({
+      agent: s.agent,
+      dates: [s.date]
+    }), De(n) > e) {
+      n.pop();
+      break;
+    }
+    r = r.slice(1);
+  }
+  return {
+    heartbeatsToSend: n,
+    unsentEntries: r
+  };
+}
+class Un {
+  constructor(e) {
+    this.app = e, this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();
+  }
+  async runIndexedDBEnvironmentCheck() {
+    return yt() ? Et().then(() => !0).catch(() => !1) : !1;
+  }
+  /**
+   * Read all heartbeats.
+   */
+  async read() {
+    return await this._canUseIndexedDBPromise ? await Sn(this.app) || { heartbeats: [] } : { heartbeats: [] };
+  }
+  // overwrite the storage with the provided heartbeats
+  async overwrite(e) {
+    var n;
+    if (await this._canUseIndexedDBPromise) {
+      const s = await this.read();
+      return Ae(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 Ae(this.app, {
+        lastSentHeartbeatDate: (n = e.lastSentHeartbeatDate) !== null && n !== void 0 ? n : s.lastSentHeartbeatDate,
+        heartbeats: [
+          ...s.heartbeats,
+          ...e.heartbeats
+        ]
+      });
+    } else
+      return;
+  }
+}
+function De(t) {
+  return q(
+    // heartbeatsCache wrapper properties
+    JSON.stringify({ version: 2, heartbeats: t })
+  ).length;
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function Pn(t) {
+  G(new $(
+    "platform-logger",
+    (e) => new qt(e),
+    "PRIVATE"
+    /* ComponentType.PRIVATE */
+  )), G(new $(
+    "heartbeat",
+    (e) => new Bn(e),
+    "PRIVATE"
+    /* ComponentType.PRIVATE */
+  )), L(le, Te, t), L(le, Te, "esm2017"), L("fire-js", "");
+}
+Pn("");
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const je = "firebasestorage.googleapis.com", Ve = "storageBucket", Ln = 2 * 60 * 1e3, Mn = 10 * 60 * 1e3;
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class d extends x {
+  /**
+   * @param code - A `StorageErrorCode` string to be prefixed with 'storage/' and
+   *  added to the end of the message.
+   * @param message  - Error message.
+   * @param status_ - Corresponding HTTP Status Code
+   */
+  constructor(e, n, r = 0) {
+    super(re(e), `Firebase Storage: ${n} (${re(e)})`), this.status_ = r, this.customData = { serverResponse: null }, this._baseMessage = this.message, Object.setPrototypeOf(this, d.prototype);
+  }
+  get status() {
+    return this.status_;
+  }
+  set status(e) {
+    this.status_ = e;
+  }
+  /**
+   * Compares a `StorageErrorCode` against this error's code, filtering out the prefix.
+   */
+  _codeEquals(e) {
+    return re(e) === this.code;
+  }
+  /**
+   * Optional response message that was added by the server.
+   */
+  get serverResponse() {
+    return this.customData.serverResponse;
+  }
+  set serverResponse(e) {
+    this.customData.serverResponse = e, this.customData.serverResponse ? this.message = `${this._baseMessage}
+${this.customData.serverResponse}` : this.message = this._baseMessage;
+  }
+}
+var h;
+(function(t) {
+  t.UNKNOWN = "unknown", t.OBJECT_NOT_FOUND = "object-not-found", t.BUCKET_NOT_FOUND = "bucket-not-found", t.PROJECT_NOT_FOUND = "project-not-found", t.QUOTA_EXCEEDED = "quota-exceeded", t.UNAUTHENTICATED = "unauthenticated", t.UNAUTHORIZED = "unauthorized", t.UNAUTHORIZED_APP = "unauthorized-app", t.RETRY_LIMIT_EXCEEDED = "retry-limit-exceeded", t.INVALID_CHECKSUM = "invalid-checksum", t.CANCELED = "canceled", t.INVALID_EVENT_NAME = "invalid-event-name", t.INVALID_URL = "invalid-url", t.INVALID_DEFAULT_BUCKET = "invalid-default-bucket", t.NO_DEFAULT_BUCKET = "no-default-bucket", t.CANNOT_SLICE_BLOB = "cannot-slice-blob", t.SERVER_FILE_WRONG_SIZE = "server-file-wrong-size", t.NO_DOWNLOAD_URL = "no-download-url", t.INVALID_ARGUMENT = "invalid-argument", t.INVALID_ARGUMENT_COUNT = "invalid-argument-count", t.APP_DELETED = "app-deleted", t.INVALID_ROOT_OPERATION = "invalid-root-operation", t.INVALID_FORMAT = "invalid-format", t.INTERNAL_ERROR = "internal-error", t.UNSUPPORTED_ENVIRONMENT = "unsupported-environment";
+})(h || (h = {}));
+function re(t) {
+  return "storage/" + t;
+}
+function pe() {
+  const t = "An unknown error occurred, please check the error payload for server response.";
+  return new d(h.UNKNOWN, t);
+}
+function $n(t) {
+  return new d(h.OBJECT_NOT_FOUND, "Object '" + t + "' does not exist.");
+}
+function Fn(t) {
+  return new d(h.QUOTA_EXCEEDED, "Quota for bucket '" + t + "' exceeded, please view quota on https://firebase.google.com/pricing/.");
+}
+function Hn() {
+  const t = "User is not authenticated, please authenticate using Firebase Authentication and try again.";
+  return new d(h.UNAUTHENTICATED, t);
+}
+function jn() {
+  return new d(h.UNAUTHORIZED_APP, "This app does not have permission to access Firebase Storage on this project.");
+}
+function Vn(t) {
+  return new d(h.UNAUTHORIZED, "User does not have permission to access '" + t + "'.");
+}
+function zn() {
+  return new d(h.RETRY_LIMIT_EXCEEDED, "Max retry time for operation exceeded, please try again.");
+}
+function Wn() {
+  return new d(h.CANCELED, "User canceled the upload/download.");
+}
+function qn(t) {
+  return new d(h.INVALID_URL, "Invalid URL '" + t + "'.");
+}
+function Gn(t) {
+  return new d(h.INVALID_DEFAULT_BUCKET, "Invalid default bucket '" + t + "'.");
+}
+function Kn() {
+  return new d(h.NO_DEFAULT_BUCKET, "No default bucket found. Did you set the '" + Ve + "' property when initializing the app?");
+}
+function Xn() {
+  return new d(h.CANNOT_SLICE_BLOB, "Cannot slice blob for upload. Please retry the upload.");
+}
+function Jn() {
+  return new d(h.NO_DOWNLOAD_URL, "The given file does not have any download URLs.");
+}
+function Yn(t) {
+  return new d(h.UNSUPPORTED_ENVIRONMENT, `${t} is missing. Make sure to install the required polyfills. See https://firebase.google.com/docs/web/environments-js-sdk#polyfills for more information.`);
+}
+function de(t) {
+  return new d(h.INVALID_ARGUMENT, t);
+}
+function ze() {
+  return new d(h.APP_DELETED, "The Firebase app was deleted.");
+}
+function Zn(t) {
+  return new d(h.INVALID_ROOT_OPERATION, "The operation '" + t + "' cannot be performed on a root reference, create a non-root reference using child, such as .child('file.png').");
+}
+function M(t, e) {
+  return new d(h.INVALID_FORMAT, "String does not match format '" + t + "': " + e);
+}
+function P(t) {
+  throw new d(h.INTERNAL_ERROR, "Internal error: " + t);
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class E {
+  constructor(e, n) {
+    this.bucket = e, this.path_ = n;
+  }
+  get path() {
+    return this.path_;
+  }
+  get isRoot() {
+    return this.path.length === 0;
+  }
+  fullServerUrl() {
+    const e = encodeURIComponent;
+    return "/b/" + e(this.bucket) + "/o/" + e(this.path);
+  }
+  bucketOnlyServerUrl() {
+    return "/b/" + encodeURIComponent(this.bucket) + "/o";
+  }
+  static makeFromBucketSpec(e, n) {
+    let r;
+    try {
+      r = E.makeFromUrl(e, n);
+    } catch {
+      return new E(e, "");
+    }
+    if (r.path === "")
+      return r;
+    throw Gn(e);
+  }
+  static makeFromUrl(e, n) {
+    let r = null;
+    const s = "([A-Za-z0-9.\\-_]+)";
+    function o(y) {
+      y.path.charAt(y.path.length - 1) === "/" && (y.path_ = y.path_.slice(0, -1));
+    }
+    const i = "(/(.*))?$", a = new RegExp("^gs://" + s + i, "i"), c = { bucket: 1, path: 3 };
+    function l(y) {
+      y.path_ = decodeURIComponent(y.path);
+    }
+    const g = "v[A-Za-z0-9_]+", f = n.replace(/[.]/g, "\\."), p = "(/([^?#]*).*)?$", m = new RegExp(`^https?://${f}/${g}/b/${s}/o${p}`, "i"), w = { bucket: 1, path: 3 }, k = n === je ? "(?:storage.googleapis.com|storage.cloud.google.com)" : n, b = "([^?#]*)", B = new RegExp(`^https?://${k}/${s}/${b}`, "i"), I = [
+      { regex: a, indices: c, postModify: o },
+      {
+        regex: m,
+        indices: w,
+        postModify: l
+      },
+      {
+        regex: B,
+        indices: { bucket: 1, path: 2 },
+        postModify: l
+      }
+    ];
+    for (let y = 0; y < I.length; y++) {
+      const V = I[y], J = V.regex.exec(e);
+      if (J) {
+        const st = J[V.indices.bucket];
+        let Y = J[V.indices.path];
+        Y || (Y = ""), r = new E(st, Y), V.postModify(r);
+        break;
+      }
+    }
+    if (r == null)
+      throw qn(e);
+    return r;
+  }
+}
+class Qn {
+  constructor(e) {
+    this.promise_ = Promise.reject(e);
+  }
+  /** @inheritDoc */
+  getPromise() {
+    return this.promise_;
+  }
+  /** @inheritDoc */
+  cancel(e = !1) {
+  }
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function er(t, e, n) {
+  let r = 1, s = null, o = null, i = !1, a = 0;
+  function c() {
+    return a === 2;
+  }
+  let l = !1;
+  function g(...b) {
+    l || (l = !0, e.apply(null, b));
+  }
+  function f(b) {
+    s = setTimeout(() => {
+      s = null, t(m, c());
+    }, b);
+  }
+  function p() {
+    o && clearTimeout(o);
+  }
+  function m(b, ...B) {
+    if (l) {
+      p();
+      return;
+    }
+    if (b) {
+      p(), g.call(null, b, ...B);
+      return;
+    }
+    if (c() || i) {
+      p(), g.call(null, b, ...B);
+      return;
+    }
+    r < 64 && (r *= 2);
+    let I;
+    a === 1 ? (a = 2, I = 0) : I = (r + Math.random()) * 1e3, f(I);
+  }
+  let w = !1;
+  function k(b) {
+    w || (w = !0, p(), !l && (s !== null ? (b || (a = 2), clearTimeout(s), f(0)) : b || (a = 1)));
+  }
+  return f(0), o = setTimeout(() => {
+    i = !0, k(!0);
+  }, n), k;
+}
+function tr(t) {
+  t(!1);
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function nr(t) {
+  return t !== void 0;
+}
+function rr(t) {
+  return typeof t == "object" && !Array.isArray(t);
+}
+function ge(t) {
+  return typeof t == "string" || t instanceof String;
+}
+function Ce(t) {
+  return me() && t instanceof Blob;
+}
+function me() {
+  return typeof Blob < "u" && !bt();
+}
+function Oe(t, e, n, r) {
+  if (r < e)
+    throw de(`Invalid value for '${t}'. Expected ${e} or greater.`);
+  if (r > n)
+    throw de(`Invalid value for '${t}'. Expected ${n} or less.`);
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function j(t, e, n) {
+  let r = e;
+  return n == null && (r = `https://${e}`), `${n}://${r}/v0${t}`;
+}
+function We(t) {
+  const e = encodeURIComponent;
+  let n = "?";
+  for (const r in t)
+    if (t.hasOwnProperty(r)) {
+      const s = e(r) + "=" + e(t[r]);
+      n = n + s + "&";
+    }
+  return n = n.slice(0, -1), n;
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var O;
+(function(t) {
+  t[t.NO_ERROR = 0] = "NO_ERROR", t[t.NETWORK_ERROR = 1] = "NETWORK_ERROR", t[t.ABORT = 2] = "ABORT";
+})(O || (O = {}));
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function sr(t, e) {
+  const n = t >= 500 && t < 600, s = [
+    // Request Timeout: web server didn't receive full request in time.
+    408,
+    // Too Many Requests: you're getting rate-limited, basically.
+    429
+  ].indexOf(t) !== -1, o = e.indexOf(t) !== -1;
+  return n || s || o;
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class or {
+  constructor(e, n, r, s, o, i, a, c, l, g, f, p = !0) {
+    this.url_ = e, this.method_ = n, this.headers_ = r, this.body_ = s, this.successCodes_ = o, this.additionalRetryCodes_ = i, this.callback_ = a, this.errorCallback_ = c, this.timeout_ = l, this.progressCallback_ = g, this.connectionFactory_ = f, this.retry = p, this.pendingConnection_ = null, this.backoffId_ = null, this.canceled_ = !1, this.appDelete_ = !1, this.promise_ = new Promise((m, w) => {
+      this.resolve_ = m, this.reject_ = w, this.start_();
+    });
+  }
+  /**
+   * Actually starts the retry loop.
+   */
+  start_() {
+    const e = (r, s) => {
+      if (s) {
+        r(!1, new z(!1, null, !0));
+        return;
+      }
+      const o = this.connectionFactory_();
+      this.pendingConnection_ = o;
+      const i = (a) => {
+        const c = a.loaded, l = a.lengthComputable ? a.total : -1;
+        this.progressCallback_ !== null && this.progressCallback_(c, l);
+      };
+      this.progressCallback_ !== null && o.addUploadProgressListener(i), o.send(this.url_, this.method_, this.body_, this.headers_).then(() => {
+        this.progressCallback_ !== null && o.removeUploadProgressListener(i), this.pendingConnection_ = null;
+        const a = o.getErrorCode() === O.NO_ERROR, c = o.getStatus();
+        if (!a || sr(c, this.additionalRetryCodes_) && this.retry) {
+          const g = o.getErrorCode() === O.ABORT;
+          r(!1, new z(!1, null, g));
+          return;
+        }
+        const l = this.successCodes_.indexOf(c) !== -1;
+        r(!0, new z(l, o));
+      });
+    }, n = (r, s) => {
+      const o = this.resolve_, i = this.reject_, a = s.connection;
+      if (s.wasSuccessCode)
+        try {
+          const c = this.callback_(a, a.getResponse());
+          nr(c) ? o(c) : o();
+        } catch (c) {
+          i(c);
+        }
+      else if (a !== null) {
+        const c = pe();
+        c.serverResponse = a.getErrorText(), this.errorCallback_ ? i(this.errorCallback_(a, c)) : i(c);
+      } else if (s.canceled) {
+        const c = this.appDelete_ ? ze() : Wn();
+        i(c);
+      } else {
+        const c = zn();
+        i(c);
+      }
+    };
+    this.canceled_ ? n(!1, new z(!1, null, !0)) : this.backoffId_ = er(e, n, this.timeout_);
+  }
+  /** @inheritDoc */
+  getPromise() {
+    return this.promise_;
+  }
+  /** @inheritDoc */
+  cancel(e) {
+    this.canceled_ = !0, this.appDelete_ = e || !1, this.backoffId_ !== null && tr(this.backoffId_), this.pendingConnection_ !== null && this.pendingConnection_.abort();
+  }
+}
+class z {
+  constructor(e, n, r) {
+    this.wasSuccessCode = e, this.connection = n, this.canceled = !!r;
+  }
+}
+function ir(t, e) {
+  e !== null && e.length > 0 && (t.Authorization = "Firebase " + e);
+}
+function ar(t, e) {
+  t["X-Firebase-Storage-Version"] = "webjs/" + (e ?? "AppManager");
+}
+function cr(t, e) {
+  e && (t["X-Firebase-GMPID"] = e);
+}
+function lr(t, e) {
+  e !== null && (t["X-Firebase-AppCheck"] = e);
+}
+function ur(t, e, n, r, s, o, i = !0) {
+  const a = We(t.urlParams), c = t.url + a, l = Object.assign({}, t.headers);
+  return cr(l, e), ir(l, n), ar(l, o), lr(l, r), new or(c, t.method, l, t.body, t.successCodes, t.additionalRetryCodes, t.handler, t.errorHandler, t.timeout, t.progressCallback, s, i);
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function hr() {
+  return typeof BlobBuilder < "u" ? BlobBuilder : typeof WebKitBlobBuilder < "u" ? WebKitBlobBuilder : void 0;
+}
+function dr(...t) {
+  const e = hr();
+  if (e !== void 0) {
+    const n = new e();
+    for (let r = 0; r < t.length; r++)
+      n.append(t[r]);
+    return n.getBlob();
+  } else {
+    if (me())
+      return new Blob(t);
+    throw new d(h.UNSUPPORTED_ENVIRONMENT, "This browser doesn't seem to support creating Blobs");
+  }
+}
+function fr(t, e, n) {
+  return t.webkitSlice ? t.webkitSlice(e, n) : t.mozSlice ? t.mozSlice(e, n) : t.slice ? t.slice(e, n) : null;
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function pr(t) {
+  if (typeof atob > "u")
+    throw Yn("base-64");
+  return atob(t);
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const R = {
+  /**
+   * Indicates the string should be interpreted "raw", that is, as normal text.
+   * The string will be interpreted as UTF-16, then uploaded as a UTF-8 byte
+   * sequence.
+   * Example: The string 'Hello! \\ud83d\\ude0a' becomes the byte sequence
+   * 48 65 6c 6c 6f 21 20 f0 9f 98 8a
+   */
+  RAW: "raw",
+  /**
+   * Indicates the string should be interpreted as base64-encoded data.
+   * Padding characters (trailing '='s) are optional.
+   * Example: The string 'rWmO++E6t7/rlw==' becomes the byte sequence
+   * ad 69 8e fb e1 3a b7 bf eb 97
+   */
+  BASE64: "base64",
+  /**
+   * Indicates the string should be interpreted as base64url-encoded data.
+   * Padding characters (trailing '='s) are optional.
+   * Example: The string 'rWmO--E6t7_rlw==' becomes the byte sequence
+   * ad 69 8e fb e1 3a b7 bf eb 97
+   */
+  BASE64URL: "base64url",
+  /**
+   * Indicates the string is a data URL, such as one obtained from
+   * canvas.toDataURL().
+   * Example: the string 'data:application/octet-stream;base64,aaaa'
+   * becomes the byte sequence
+   * 69 a6 9a
+   * (the content-type "application/octet-stream" is also applied, but can
+   * be overridden in the metadata object).
+   */
+  DATA_URL: "data_url"
+};
+class se {
+  constructor(e, n) {
+    this.data = e, this.contentType = n || null;
+  }
+}
+function gr(t, e) {
+  switch (t) {
+    case R.RAW:
+      return new se(qe(e));
+    case R.BASE64:
+    case R.BASE64URL:
+      return new se(Ge(t, e));
+    case R.DATA_URL:
+      return new se(_r(e), br(e));
+  }
+  throw pe();
+}
+function qe(t) {
+  const e = [];
+  for (let n = 0; n < t.length; n++) {
+    let r = t.charCodeAt(n);
+    if (r <= 127)
+      e.push(r);
+    else if (r <= 2047)
+      e.push(192 | r >> 6, 128 | r & 63);
+    else if ((r & 64512) === 55296)
+      if (!(n < t.length - 1 && (t.charCodeAt(n + 1) & 64512) === 56320))
+        e.push(239, 191, 189);
+      else {
+        const o = r, i = t.charCodeAt(++n);
+        r = 65536 | (o & 1023) << 10 | i & 1023, e.push(240 | r >> 18, 128 | r >> 12 & 63, 128 | r >> 6 & 63, 128 | r & 63);
+      }
+    else
+      (r & 64512) === 56320 ? e.push(239, 191, 189) : e.push(224 | r >> 12, 128 | r >> 6 & 63, 128 | r & 63);
+  }
+  return new Uint8Array(e);
+}
+function mr(t) {
+  let e;
+  try {
+    e = decodeURIComponent(t);
+  } catch {
+    throw M(R.DATA_URL, "Malformed data URL.");
+  }
+  return qe(e);
+}
+function Ge(t, e) {
+  switch (t) {
+    case R.BASE64: {
+      const s = e.indexOf("-") !== -1, o = e.indexOf("_") !== -1;
+      if (s || o)
+        throw M(t, "Invalid character '" + (s ? "-" : "_") + "' found: is it base64url encoded?");
+      break;
+    }
+    case R.BASE64URL: {
+      const s = e.indexOf("+") !== -1, o = e.indexOf("/") !== -1;
+      if (s || o)
+        throw M(t, "Invalid character '" + (s ? "+" : "/") + "' found: is it base64 encoded?");
+      e = e.replace(/-/g, "+").replace(/_/g, "/");
+      break;
+    }
+  }
+  let n;
+  try {
+    n = pr(e);
+  } catch (s) {
+    throw s.message.includes("polyfill") ? s : M(t, "Invalid character found");
+  }
+  const r = new Uint8Array(n.length);
+  for (let s = 0; s < n.length; s++)
+    r[s] = n.charCodeAt(s);
+  return r;
+}
+class Ke {
+  constructor(e) {
+    this.base64 = !1, this.contentType = null;
+    const n = e.match(/^data:([^,]+)?,/);
+    if (n === null)
+      throw M(R.DATA_URL, "Must be formatted 'data:[<mediatype>][;base64],<data>");
+    const r = n[1] || null;
+    r != null && (this.base64 = yr(r, ";base64"), this.contentType = this.base64 ? r.substring(0, r.length - 7) : r), this.rest = e.substring(e.indexOf(",") + 1);
+  }
+}
+function _r(t) {
+  const e = new Ke(t);
+  return e.base64 ? Ge(R.BASE64, e.rest) : mr(e.rest);
+}
+function br(t) {
+  return new Ke(t).contentType;
+}
+function yr(t, e) {
+  return t.length >= e.length ? t.substring(t.length - e.length) === e : !1;
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class T {
+  constructor(e, n) {
+    let r = 0, s = "";
+    Ce(e) ? (this.data_ = e, r = e.size, s = e.type) : e instanceof ArrayBuffer ? (n ? this.data_ = new Uint8Array(e) : (this.data_ = new Uint8Array(e.byteLength), this.data_.set(new Uint8Array(e))), r = this.data_.length) : e instanceof Uint8Array && (n ? this.data_ = e : (this.data_ = new Uint8Array(e.length), this.data_.set(e)), r = e.length), this.size_ = r, this.type_ = s;
+  }
+  size() {
+    return this.size_;
+  }
+  type() {
+    return this.type_;
+  }
+  slice(e, n) {
+    if (Ce(this.data_)) {
+      const r = this.data_, s = fr(r, e, n);
+      return s === null ? null : new T(s);
+    } else {
+      const r = new Uint8Array(this.data_.buffer, e, n - e);
+      return new T(r, !0);
+    }
+  }
+  static getBlob(...e) {
+    if (me()) {
+      const n = e.map((r) => r instanceof T ? r.data_ : r);
+      return new T(dr.apply(null, n));
+    } else {
+      const n = e.map((i) => ge(i) ? gr(R.RAW, i).data : i.data_);
+      let r = 0;
+      n.forEach((i) => {
+        r += i.byteLength;
+      });
+      const s = new Uint8Array(r);
+      let o = 0;
+      return n.forEach((i) => {
+        for (let a = 0; a < i.length; a++)
+          s[o++] = i[a];
+      }), new T(s, !0);
+    }
+  }
+  uploadData() {
+    return this.data_;
+  }
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function Xe(t) {
+  let e;
+  try {
+    e = JSON.parse(t);
+  } catch {
+    return null;
+  }
+  return rr(e) ? e : null;
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function Er(t) {
+  if (t.length === 0)
+    return null;
+  const e = t.lastIndexOf("/");
+  return e === -1 ? "" : t.slice(0, e);
+}
+function wr(t, e) {
+  const n = e.split("/").filter((r) => r.length > 0).join("/");
+  return t.length === 0 ? n : t + "/" + n;
+}
+function Je(t) {
+  const e = t.lastIndexOf("/", t.length - 2);
+  return e === -1 ? t : t.slice(e + 1);
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function Ir(t, e) {
+  return e;
+}
+class _ {
+  constructor(e, n, r, s) {
+    this.server = e, this.local = n || e, this.writable = !!r, this.xform = s || Ir;
+  }
+}
+let W = null;
+function Rr(t) {
+  return !ge(t) || t.length < 2 ? t : Je(t);
+}
+function Ye() {
+  if (W)
+    return W;
+  const t = [];
+  t.push(new _("bucket")), t.push(new _("generation")), t.push(new _("metageneration")), t.push(new _("name", "fullPath", !0));
+  function e(o, i) {
+    return Rr(i);
+  }
+  const n = new _("name");
+  n.xform = e, t.push(n);
+  function r(o, i) {
+    return i !== void 0 ? Number(i) : i;
+  }
+  const s = new _("size");
+  return s.xform = r, t.push(s), t.push(new _("timeCreated")), t.push(new _("updated")), t.push(new _("md5Hash", null, !0)), t.push(new _("cacheControl", null, !0)), t.push(new _("contentDisposition", null, !0)), t.push(new _("contentEncoding", null, !0)), t.push(new _("contentLanguage", null, !0)), t.push(new _("contentType", null, !0)), t.push(new _("metadata", "customMetadata", !0)), W = t, W;
+}
+function Tr(t, e) {
+  function n() {
+    const r = t.bucket, s = t.fullPath, o = new E(r, s);
+    return e._makeStorageReference(o);
+  }
+  Object.defineProperty(t, "ref", { get: n });
+}
+function Ar(t, e, n) {
+  const r = {};
+  r.type = "file";
+  const s = n.length;
+  for (let o = 0; o < s; o++) {
+    const i = n[o];
+    r[i.local] = i.xform(r, e[i.server]);
+  }
+  return Tr(r, t), r;
+}
+function Ze(t, e, n) {
+  const r = Xe(e);
+  return r === null ? null : Ar(t, r, n);
+}
+function vr(t, e, n, r) {
+  const s = Xe(e);
+  if (s === null || !ge(s.downloadTokens))
+    return null;
+  const o = s.downloadTokens;
+  if (o.length === 0)
+    return null;
+  const i = encodeURIComponent;
+  return o.split(",").map((l) => {
+    const g = t.bucket, f = t.fullPath, p = "/b/" + i(g) + "/o/" + i(f), m = j(p, n, r), w = We({
+      alt: "media",
+      token: l
+    });
+    return m + w;
+  })[0];
+}
+function Dr(t, e) {
+  const n = {}, r = e.length;
+  for (let s = 0; s < r; s++) {
+    const o = e[s];
+    o.writable && (n[o.server] = t[o.local]);
+  }
+  return JSON.stringify(n);
+}
+class X {
+  constructor(e, n, r, s) {
+    this.url = e, this.method = n, this.handler = r, this.timeout = s, this.urlParams = {}, this.headers = {}, this.body = null, this.errorHandler = null, this.progressCallback = null, this.successCodes = [200], this.additionalRetryCodes = [];
+  }
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function Qe(t) {
+  if (!t)
+    throw pe();
+}
+function Cr(t, e) {
+  function n(r, s) {
+    const o = Ze(t, s, e);
+    return Qe(o !== null), o;
+  }
+  return n;
+}
+function Or(t, e) {
+  function n(r, s) {
+    const o = Ze(t, s, e);
+    return Qe(o !== null), vr(o, s, t.host, t._protocol);
+  }
+  return n;
+}
+function et(t) {
+  function e(n, r) {
+    let s;
+    return n.getStatus() === 401 ? /* This exact message string is the only consistent part of the */ /* server's error response that identifies it as an App Check error. */ n.getErrorText().includes("Firebase App Check token is invalid") ? s = jn() : s = Hn() : n.getStatus() === 402 ? s = Fn(t.bucket) : n.getStatus() === 403 ? s = Vn(t.path) : s = r, s.status = n.getStatus(), s.serverResponse = r.serverResponse, s;
+  }
+  return e;
+}
+function _e(t) {
+  const e = et(t);
+  function n(r, s) {
+    let o = e(r, s);
+    return r.getStatus() === 404 && (o = $n(t.path)), o.serverResponse = s.serverResponse, o;
+  }
+  return n;
+}
+function Sr(t, e, n) {
+  const r = e.fullServerUrl(), s = j(r, t.host, t._protocol) + "?alt=media", o = "GET", i = t.maxOperationRetryTime, a = new X(s, o, (c, l) => l, i);
+  return a.errorHandler = _e(e), n !== void 0 && (a.headers.Range = `bytes=0-${n}`, a.successCodes = [
+    200,
+    206
+    /* Partial Content */
+  ]), a;
+}
+function Nr(t, e, n) {
+  const r = e.fullServerUrl(), s = j(r, t.host, t._protocol), o = "GET", i = t.maxOperationRetryTime, a = new X(s, o, Or(t, n), i);
+  return a.errorHandler = _e(e), a;
+}
+function kr(t, e) {
+  const n = e.fullServerUrl(), r = j(n, t.host, t._protocol), s = "DELETE", o = t.maxOperationRetryTime;
+  function i(c, l) {
+  }
+  const a = new X(r, s, i, o);
+  return a.successCodes = [200, 204], a.errorHandler = _e(e), a;
+}
+function Br(t, e) {
+  return t && t.contentType || e && e.type() || "application/octet-stream";
+}
+function xr(t, e, n) {
+  const r = Object.assign({}, n);
+  return r.fullPath = t.path, r.size = e.size(), r.contentType || (r.contentType = Br(null, e)), r;
+}
+function Ur(t, e, n, r, s) {
+  const o = e.bucketOnlyServerUrl(), i = {
+    "X-Goog-Upload-Protocol": "multipart"
+  };
+  function a() {
+    let I = "";
+    for (let y = 0; y < 2; y++)
+      I = I + Math.random().toString().slice(2);
+    return I;
+  }
+  const c = a();
+  i["Content-Type"] = "multipart/related; boundary=" + c;
+  const l = xr(e, r, s), g = Dr(l, n), f = "--" + c + `\r
+Content-Type: application/json; charset=utf-8\r
+\r
+` + g + `\r
+--` + c + `\r
+Content-Type: ` + l.contentType + `\r
+\r
+`, p = `\r
+--` + c + "--", m = T.getBlob(f, r, p);
+  if (m === null)
+    throw Xn();
+  const w = { name: l.fullPath }, k = j(o, t.host, t._protocol), b = "POST", B = t.maxUploadRetryTime, D = new X(k, b, Cr(t, n), B);
+  return D.urlParams = w, D.headers = i, D.body = m.uploadData(), D.errorHandler = et(e), D;
+}
+class tt {
+  constructor() {
+    this.sent_ = !1, this.xhr_ = new XMLHttpRequest(), this.initXhr(), this.errorCode_ = O.NO_ERROR, this.sendPromise_ = new Promise((e) => {
+      this.xhr_.addEventListener("abort", () => {
+        this.errorCode_ = O.ABORT, e();
+      }), this.xhr_.addEventListener("error", () => {
+        this.errorCode_ = O.NETWORK_ERROR, e();
+      }), this.xhr_.addEventListener("load", () => {
+        e();
+      });
+    });
+  }
+  send(e, n, r, s) {
+    if (this.sent_)
+      throw P("cannot .send() more than once");
+    if (this.sent_ = !0, this.xhr_.open(n, e, !0), s !== void 0)
+      for (const o in s)
+        s.hasOwnProperty(o) && this.xhr_.setRequestHeader(o, s[o].toString());
+    return r !== void 0 ? this.xhr_.send(r) : this.xhr_.send(), this.sendPromise_;
+  }
+  getErrorCode() {
+    if (!this.sent_)
+      throw P("cannot .getErrorCode() before sending");
+    return this.errorCode_;
+  }
+  getStatus() {
+    if (!this.sent_)
+      throw P("cannot .getStatus() before sending");
+    try {
+      return this.xhr_.status;
+    } catch {
+      return -1;
+    }
+  }
+  getResponse() {
+    if (!this.sent_)
+      throw P("cannot .getResponse() before sending");
+    return this.xhr_.response;
+  }
+  getErrorText() {
+    if (!this.sent_)
+      throw P("cannot .getErrorText() before sending");
+    return this.xhr_.statusText;
+  }
+  /** Aborts the request. */
+  abort() {
+    this.xhr_.abort();
+  }
+  getResponseHeader(e) {
+    return this.xhr_.getResponseHeader(e);
+  }
+  addUploadProgressListener(e) {
+    this.xhr_.upload != null && this.xhr_.upload.addEventListener("progress", e);
+  }
+  removeUploadProgressListener(e) {
+    this.xhr_.upload != null && this.xhr_.upload.removeEventListener("progress", e);
+  }
+}
+class Pr extends tt {
+  initXhr() {
+    this.xhr_.responseType = "text";
+  }
+}
+function be() {
+  return new Pr();
+}
+class Lr extends tt {
+  initXhr() {
+    this.xhr_.responseType = "blob";
+  }
+}
+function Mr() {
+  return new Lr();
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class N {
+  constructor(e, n) {
+    this._service = e, n instanceof E ? this._location = n : this._location = E.makeFromUrl(n, e.host);
+  }
+  /**
+   * Returns the URL for the bucket and path this object references,
+   *     in the form gs://<bucket>/<object-path>
+   * @override
+   */
+  toString() {
+    return "gs://" + this._location.bucket + "/" + this._location.path;
+  }
+  _newRef(e, n) {
+    return new N(e, n);
+  }
+  /**
+   * A reference to the root of this object's bucket.
+   */
+  get root() {
+    const e = new E(this._location.bucket, "");
+    return this._newRef(this._service, e);
+  }
+  /**
+   * The name of the bucket containing this reference's object.
+   */
+  get bucket() {
+    return this._location.bucket;
+  }
+  /**
+   * The full path of this object.
+   */
+  get fullPath() {
+    return this._location.path;
+  }
+  /**
+   * The short name of this object, which is the last component of the full path.
+   * For example, if fullPath is 'full/path/image.png', name is 'image.png'.
+   */
+  get name() {
+    return Je(this._location.path);
+  }
+  /**
+   * The `StorageService` instance this `StorageReference` is associated with.
+   */
+  get storage() {
+    return this._service;
+  }
+  /**
+   * A `StorageReference` pointing to the parent location of this `StorageReference`, or null if
+   * this reference is the root.
+   */
+  get parent() {
+    const e = Er(this._location.path);
+    if (e === null)
+      return null;
+    const n = new E(this._location.bucket, e);
+    return new N(this._service, n);
+  }
+  /**
+   * Utility function to throw an error in methods that do not accept a root reference.
+   */
+  _throwIfRoot(e) {
+    if (this._location.path === "")
+      throw Zn(e);
+  }
+}
+function $r(t, e) {
+  t._throwIfRoot("getBlob");
+  const n = Sr(t.storage, t._location, e);
+  return t.storage.makeRequestWithTokens(n, Mr).then((r) => e !== void 0 ? (
+    // GCS may not honor the Range header for small files
+    r.slice(0, e)
+  ) : r);
+}
+function Fr(t, e, n) {
+  t._throwIfRoot("uploadBytes");
+  const r = Ur(t.storage, t._location, Ye(), new T(e, !0), n);
+  return t.storage.makeRequestWithTokens(r, be).then((s) => ({
+    metadata: s,
+    ref: t
+  }));
+}
+function Hr(t) {
+  t._throwIfRoot("getDownloadURL");
+  const e = Nr(t.storage, t._location, Ye());
+  return t.storage.makeRequestWithTokens(e, be).then((n) => {
+    if (n === null)
+      throw Jn();
+    return n;
+  });
+}
+function jr(t) {
+  t._throwIfRoot("deleteObject");
+  const e = kr(t.storage, t._location);
+  return t.storage.makeRequestWithTokens(e, be);
+}
+function Vr(t, e) {
+  const n = wr(t._location.path, e), r = new E(t._location.bucket, n);
+  return new N(t.storage, r);
+}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function zr(t) {
+  return /^[A-Za-z]+:\/\//.test(t);
+}
+function Wr(t, e) {
+  return new N(t, e);
+}
+function nt(t, e) {
+  if (t instanceof ye) {
+    const n = t;
+    if (n._bucket == null)
+      throw Kn();
+    const r = new N(n, n._bucket);
+    return e != null ? nt(r, e) : r;
+  } else
+    return e !== void 0 ? Vr(t, e) : t;
+}
+function qr(t, e) {
+  if (e && zr(e)) {
+    if (t instanceof ye)
+      return Wr(t, e);
+    throw de("To use ref(service, url), the first argument must be a Storage instance.");
+  } else
+    return nt(t, e);
+}
+function Se(t, e) {
+  const n = e == null ? void 0 : e[Ve];
+  return n == null ? null : E.makeFromBucketSpec(n, t);
+}
+function Gr(t, e, n, r = {}) {
+  t.host = `${e}:${n}`, t._protocol = "http";
+  const { mockUserToken: s } = r;
+  s && (t._overrideAuthToken = typeof s == "string" ? s : _t(s, t.app.options.projectId));
+}
+class ye {
+  constructor(e, n, r, s, o) {
+    this.app = e, this._authProvider = n, this._appCheckProvider = r, this._url = s, this._firebaseVersion = o, this._bucket = null, this._host = je, this._protocol = "https", this._appId = null, this._deleted = !1, this._maxOperationRetryTime = Ln, this._maxUploadRetryTime = Mn, this._requests = /* @__PURE__ */ new Set(), s != null ? this._bucket = E.makeFromBucketSpec(s, this._host) : this._bucket = Se(this._host, this.app.options);
+  }
+  /**
+   * The host string for this service, in the form of `host` or
+   * `host:port`.
+   */
+  get host() {
+    return this._host;
+  }
+  set host(e) {
+    this._host = e, this._url != null ? this._bucket = E.makeFromBucketSpec(this._url, e) : this._bucket = Se(e, this.app.options);
+  }
+  /**
+   * The maximum time to retry uploads in milliseconds.
+   */
+  get maxUploadRetryTime() {
+    return this._maxUploadRetryTime;
+  }
+  set maxUploadRetryTime(e) {
+    Oe(
+      "time",
+      /* minValue=*/
+      0,
+      /* maxValue= */
+      Number.POSITIVE_INFINITY,
+      e
+    ), this._maxUploadRetryTime = e;
+  }
+  /**
+   * The maximum time to retry operations other than uploads or downloads in
+   * milliseconds.
+   */
+  get maxOperationRetryTime() {
+    return this._maxOperationRetryTime;
+  }
+  set maxOperationRetryTime(e) {
+    Oe(
+      "time",
+      /* minValue=*/
+      0,
+      /* maxValue= */
+      Number.POSITIVE_INFINITY,
+      e
+    ), this._maxOperationRetryTime = e;
+  }
+  async _getAuthToken() {
+    if (this._overrideAuthToken)
+      return this._overrideAuthToken;
+    const e = this._authProvider.getImmediate({ optional: !0 });
+    if (e) {
+      const n = await e.getToken();
+      if (n !== null)
+        return n.accessToken;
+    }
+    return null;
+  }
+  async _getAppCheckToken() {
+    const e = this._appCheckProvider.getImmediate({ optional: !0 });
+    return e ? (await e.getToken()).token : null;
+  }
+  /**
+   * Stop running requests and prevent more from being created.
+   */
+  _delete() {
+    return this._deleted || (this._deleted = !0, this._requests.forEach((e) => e.cancel()), this._requests.clear()), Promise.resolve();
+  }
+  /**
+   * Returns a new firebaseStorage.Reference object referencing this StorageService
+   * at the given Location.
+   */
+  _makeStorageReference(e) {
+    return new N(this, e);
+  }
+  /**
+   * @param requestInfo - HTTP RequestInfo object
+   * @param authToken - Firebase auth token
+   */
+  _makeRequest(e, n, r, s, o = !0) {
+    if (this._deleted)
+      return new Qn(ze());
+    {
+      const i = ur(e, this._appId, r, s, n, this._firebaseVersion, o);
+      return this._requests.add(i), i.getPromise().then(() => this._requests.delete(i), () => this._requests.delete(i)), i;
+    }
+  }
+  async makeRequestWithTokens(e, n) {
+    const [r, s] = await Promise.all([
+      this._getAuthToken(),
+      this._getAppCheckToken()
+    ]);
+    return this._makeRequest(e, n, r, s).getPromise();
+  }
+}
+const Ne = "@firebase/storage", ke = "0.11.2";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const rt = "storage";
+function ds(t, e, n) {
+  return t = U(t), Fr(t, e, n);
+}
+function fs(t) {
+  return t = U(t), Hr(t);
+}
+function ps(t) {
+  return t = U(t), jr(t);
+}
+function gs(t, e) {
+  return t = U(t), qr(t, e);
+}
+function ms(t = Dn(), e) {
+  t = U(t);
+  const r = In(t, rt).getImmediate({
+    identifier: e
+  }), s = gt("storage");
+  return s && Kr(r, ...s), r;
+}
+function Kr(t, e, n, r = {}) {
+  Gr(t, e, n, r);
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function _s(t, e) {
+  return t = U(t), $r(t, e);
+}
+function Xr(t, { instanceIdentifier: e }) {
+  const n = t.getProvider("app").getImmediate(), r = t.getProvider("auth-internal"), s = t.getProvider("app-check-internal");
+  return new ye(n, r, s, e, An);
+}
+function Jr() {
+  G(new $(
+    rt,
+    Xr,
+    "PUBLIC"
+    /* ComponentType.PUBLIC */
+  ).setMultipleInstances(!0)), L(Ne, ke, ""), L(Ne, ke, "esm2017");
+}
+Jr();
+export {
+  _s as A,
+  ds as B,
+  $ as C,
+  fs as D,
+  Le as E,
+  x as F,
+  ps as G,
+  u as L,
+  An as S,
+  G as _,
+  is as a,
+  os as b,
+  U as c,
+  us as d,
+  In as e,
+  pt as f,
+  rs as g,
+  Dn as h,
+  ss as i,
+  Pe as j,
+  ie as k,
+  xt as l,
+  lt as m,
+  as as n,
+  cs as o,
+  hs as p,
+  ls as q,
+  L as r,
+  vn as s,
+  ms as t,
+  Zr as u,
+  Qr as v,
+  es as w,
+  ns as x,
+  ts as y,
+  gs as z
+};