@feedmepos/mf-connect 0.0.22-prod → 0.0.25-prod

package/dist/App-BpN5YKl3.js

@@ -0,0 +1,4610 @@
+import { defineComponent as lt, ref as te, h as Q, watch as ut, resolveComponent as Yt, openBlock as ne, createBlock as dt, unref as P, computed as Ve, onMounted as Xt, createElementBlock as He, Fragment as Qt, createCommentVNode as $e, createVNode as Zt, createElementVNode as en, nextTick as tn } from "vue";
+import { useRouter as nn, useRoute as ht, RouterView as rn } from "vue-router";
+import { useCoreStore as We, FeedMeAuth as sn } from "@feedmepos/mf-common";
+import { u as on } from "./app-wDQR6dpb.js";
+import { u as an } from "./business-Cb7TdO2i.js";
+import "./index-BBJiSjAD.js";
+import { components as Z, useSnackbar as cn, useDialog as ln } from "@feedmepos/ui-library";
+import { R as f } from "./app-BS8VGmru.js";
+import { J as un } from "./JsonViewer-v8_C7l5N.js";
+import { r as ye, L as dn, g as ft, i as hn, a as fn, _ as je, C as Ge, b as pn, S as z, c as w, d as j, E as be, e as mn, f as pt, h as gn, j as _n, k as mt, l as m, m as vn, F as Re, n as In, q as K, o as Tn, p as wn, s as yn, t as En, u as kn } from "./index.esm2017-DVHSqcDL.js";
+import { _ as Pe } from "./tslib.es6-BCqqvLQ_.js";
+import { S as Be } from "./index-DU11jl6w.js";
+const Sn = /* @__PURE__ */ lt({
+  __name: "NavigationTab",
+  setup(n) {
+    const e = te(), t = [
+      {
+        label: "Analytic",
+        value: f["$connect-ANALYTIC"]
+      },
+      {
+        label: "Campaign",
+        value: f["$connect-CAMPAIGN"],
+        children: [
+          {
+            label: "Promotion",
+            value: f["$connect-CAMPAIGN_PROMOTION"]
+          },
+          {
+            label: "Voucher",
+            value: f["$connect-CAMPAIGN_VOUCHER"]
+          },
+          {
+            label: "Broadcast",
+            value: f["$connect-CAMPAIGN_BROADCAST"]
+          }
+        ]
+      },
+      {
+        label: "Program",
+        value: f["$connect-PROGRAM"],
+        children: [
+          {
+            label: "Tier",
+            value: f["$connect-PROGRAM_TIER"]
+          },
+          {
+            label: "Title",
+            value: f["$connect-PROGRAM_TITLE"]
+          },
+          {
+            label: "Experience",
+            value: f["$connect-PROGRAM_EXPERIENCE"]
+          },
+          {
+            label: "Point",
+            value: f["$connect-PROGRAM_POINT"],
+            badge: () => Q(Z.FmPill, { variant: "premium" })
+          },
+          {
+            label: "Credit",
+            value: f["$connect-PROGRAM_CREDIT"]
+          },
+          {
+            label: "Game",
+            value: f["$connect-PROGRAM_GAME"],
+            badge: () => Q(Z.FmPill, { variant: "premium" })
+          },
+          {
+            label: "Mission",
+            value: f["$connect-PROGRAM_MISSION"]
+          }
+        ]
+      },
+      {
+        label: "Loyalty",
+        value: f["$connect-LOYALTY"],
+        children: [
+          {
+            label: "Member",
+            value: f["$connect-LOYALTY_MEMBER_LIST"]
+          },
+          {
+            label: "Segments",
+            value: f["$connect-LOYALTY_SEGMENT"],
+            badge: () => Q(Z.FmPill, { variant: "premium" })
+          },
+          {
+            label: "Card",
+            value: f["$connect-LOYALTY_CARD"],
+            badge: () => Q(Z.FmPill, { variant: "premium" })
+          }
+        ]
+      },
+      {
+        label: "Store",
+        value: f["$connect-STORE"]
+      },
+      {
+        label: "Transaction",
+        value: f["$connect-TRANSACTION"]
+      },
+      // {
+      //   label: 'Marketing material',
+      //   value: ROUTE_NAME['$connect-MARKETING'],
+      // },
+      {
+        label: "Setting",
+        value: f["$connect-SETTING"]
+      }
+    ], i = nn(), r = ht(), s = t.reduce((c, a) => [...(a.children ?? []).map((l) => l.value), ...c, a.value], []);
+    ut(
+      () => r,
+      (c) => {
+        const a = c.matched.map((l) => l.name).reverse();
+        e.value = a.find((l) => s.includes(l));
+      },
+      { immediate: !0 }
+    );
+    async function o(c) {
+      await i.push({ name: c });
+    }
+    return (c, a) => {
+      var d;
+      const l = Yt("FmCollapsibleTabs");
+      return ne(), dt(l, {
+        class: "border-fm-color-neutral-gray-100 border-r py-16 px-4",
+        "model-value": (d = P(e)) == null ? void 0 : d.toString(),
+        items: t,
+        "onUpdate:modelValue": o
+      }, null, 8, ["model-value"]);
+    };
+  }
+});
+var bn = "firebase", Rn = "10.12.4";
+/**
+ * @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.
+ */
+ye(bn, Rn, "app");
+function gt() {
+  return {
+    "dependent-sdk-initialized-before-auth": "Another Firebase SDK was initialized and is trying to use Auth before Auth is initialized. Please be sure to call `initializeAuth` or `getAuth` before starting any other Firebase SDK."
+  };
+}
+const Pn = gt, _t = new be("auth", "Firebase", gt());
+/**
+ * @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 ae = new dn("@firebase/auth");
+function An(n, ...e) {
+  ae.logLevel <= mt.WARN && ae.warn(`Auth (${z}): ${n}`, ...e);
+}
+function ie(n, ...e) {
+  ae.logLevel <= mt.ERROR && ae.error(`Auth (${z}): ${n}`, ...e);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function S(n, ...e) {
+  throw Ae(n, ...e);
+}
+function I(n, ...e) {
+  return Ae(n, ...e);
+}
+function vt(n, e, t) {
+  const i = Object.assign(Object.assign({}, Pn()), { [e]: t });
+  return new be("auth", "Firebase", i).create(e, {
+    appName: n.name
+  });
+}
+function L(n) {
+  return vt(n, "operation-not-supported-in-this-environment", "Operations that alter the current user are not supported in conjunction with FirebaseServerApp");
+}
+function Ae(n, ...e) {
+  if (typeof n != "string") {
+    const t = e[0], i = [...e.slice(1)];
+    return i[0] && (i[0].appName = n.name), n._errorFactory.create(t, ...i);
+  }
+  return _t.create(n, ...e);
+}
+function u(n, e, ...t) {
+  if (!n)
+    throw Ae(e, ...t);
+}
+function y(n) {
+  const e = "INTERNAL ASSERTION FAILED: " + n;
+  throw ie(e), new Error(e);
+}
+function b(n, e) {
+  n || y(e);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function Ee() {
+  var n;
+  return typeof self < "u" && ((n = self.location) === null || n === void 0 ? void 0 : n.href) || "";
+}
+function Cn() {
+  return qe() === "http:" || qe() === "https:";
+}
+function qe() {
+  var n;
+  return typeof self < "u" && ((n = self.location) === null || n === void 0 ? void 0 : n.protocol) || null;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function On() {
+  return typeof navigator < "u" && navigator && "onLine" in navigator && typeof navigator.onLine == "boolean" && // Apply only for traditional web apps and Chrome extensions.
+  // This is especially true for Cordova apps which have unreliable
+  // navigator.onLine behavior unless cordova-plugin-network-information is
+  // installed which overwrites the native navigator.onLine value and
+  // defines navigator.connection.
+  (Cn() || pn() || "connection" in navigator) ? navigator.onLine : !0;
+}
+function Nn() {
+  if (typeof navigator > "u")
+    return null;
+  const n = navigator;
+  return (
+    // Most reliable, but only supported in Chrome/Firefox.
+    n.languages && n.languages[0] || // Supported in most browsers, but returns the language of the browser
+    // UI, not the language set in browser settings.
+    n.language || // Couldn't determine language.
+    null
+  );
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class J {
+  constructor(e, t) {
+    this.shortDelay = e, this.longDelay = t, b(t > e, "Short delay should be less than long delay!"), this.isMobile = hn() || fn();
+  }
+  get() {
+    return On() ? this.isMobile ? this.longDelay : this.shortDelay : Math.min(5e3, this.shortDelay);
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function Ce(n, e) {
+  b(n.emulator, "Emulator should always be set here");
+  const { url: t } = n.emulator;
+  return e ? `${t}${e.startsWith("/") ? e.slice(1) : e}` : t;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class It {
+  static initialize(e, t, i) {
+    this.fetchImpl = e, t && (this.headersImpl = t), i && (this.responseImpl = i);
+  }
+  static fetch() {
+    if (this.fetchImpl)
+      return this.fetchImpl;
+    if (typeof self < "u" && "fetch" in self)
+      return self.fetch;
+    if (typeof globalThis < "u" && globalThis.fetch)
+      return globalThis.fetch;
+    if (typeof fetch < "u")
+      return fetch;
+    y("Could not find fetch implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill");
+  }
+  static headers() {
+    if (this.headersImpl)
+      return this.headersImpl;
+    if (typeof self < "u" && "Headers" in self)
+      return self.Headers;
+    if (typeof globalThis < "u" && globalThis.Headers)
+      return globalThis.Headers;
+    if (typeof Headers < "u")
+      return Headers;
+    y("Could not find Headers implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill");
+  }
+  static response() {
+    if (this.responseImpl)
+      return this.responseImpl;
+    if (typeof self < "u" && "Response" in self)
+      return self.Response;
+    if (typeof globalThis < "u" && globalThis.Response)
+      return globalThis.Response;
+    if (typeof Response < "u")
+      return Response;
+    y("Could not find Response implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill");
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const Ln = {
+  // Custom token errors.
+  CREDENTIAL_MISMATCH: "custom-token-mismatch",
+  // This can only happen if the SDK sends a bad request.
+  MISSING_CUSTOM_TOKEN: "internal-error",
+  // Create Auth URI errors.
+  INVALID_IDENTIFIER: "invalid-email",
+  // This can only happen if the SDK sends a bad request.
+  MISSING_CONTINUE_URI: "internal-error",
+  // Sign in with email and password errors (some apply to sign up too).
+  INVALID_PASSWORD: "wrong-password",
+  // This can only happen if the SDK sends a bad request.
+  MISSING_PASSWORD: "missing-password",
+  // Thrown if Email Enumeration Protection is enabled in the project and the email or password is
+  // invalid.
+  INVALID_LOGIN_CREDENTIALS: "invalid-credential",
+  // Sign up with email and password errors.
+  EMAIL_EXISTS: "email-already-in-use",
+  PASSWORD_LOGIN_DISABLED: "operation-not-allowed",
+  // Verify assertion for sign in with credential errors:
+  INVALID_IDP_RESPONSE: "invalid-credential",
+  INVALID_PENDING_TOKEN: "invalid-credential",
+  FEDERATED_USER_ID_ALREADY_LINKED: "credential-already-in-use",
+  // This can only happen if the SDK sends a bad request.
+  MISSING_REQ_TYPE: "internal-error",
+  // Send Password reset email errors:
+  EMAIL_NOT_FOUND: "user-not-found",
+  RESET_PASSWORD_EXCEED_LIMIT: "too-many-requests",
+  EXPIRED_OOB_CODE: "expired-action-code",
+  INVALID_OOB_CODE: "invalid-action-code",
+  // This can only happen if the SDK sends a bad request.
+  MISSING_OOB_CODE: "internal-error",
+  // Operations that require ID token in request:
+  CREDENTIAL_TOO_OLD_LOGIN_AGAIN: "requires-recent-login",
+  INVALID_ID_TOKEN: "invalid-user-token",
+  TOKEN_EXPIRED: "user-token-expired",
+  USER_NOT_FOUND: "user-token-expired",
+  // Other errors.
+  TOO_MANY_ATTEMPTS_TRY_LATER: "too-many-requests",
+  PASSWORD_DOES_NOT_MEET_REQUIREMENTS: "password-does-not-meet-requirements",
+  // Phone Auth related errors.
+  INVALID_CODE: "invalid-verification-code",
+  INVALID_SESSION_INFO: "invalid-verification-id",
+  INVALID_TEMPORARY_PROOF: "invalid-credential",
+  MISSING_SESSION_INFO: "missing-verification-id",
+  SESSION_EXPIRED: "code-expired",
+  // Other action code errors when additional settings passed.
+  // MISSING_CONTINUE_URI is getting mapped to INTERNAL_ERROR above.
+  // This is OK as this error will be caught by client side validation.
+  MISSING_ANDROID_PACKAGE_NAME: "missing-android-pkg-name",
+  UNAUTHORIZED_DOMAIN: "unauthorized-continue-uri",
+  // getProjectConfig errors when clientId is passed.
+  INVALID_OAUTH_CLIENT_ID: "invalid-oauth-client-id",
+  // User actions (sign-up or deletion) disabled errors.
+  ADMIN_ONLY_OPERATION: "admin-restricted-operation",
+  // Multi factor related errors.
+  INVALID_MFA_PENDING_CREDENTIAL: "invalid-multi-factor-session",
+  MFA_ENROLLMENT_NOT_FOUND: "multi-factor-info-not-found",
+  MISSING_MFA_ENROLLMENT_ID: "missing-multi-factor-info",
+  MISSING_MFA_PENDING_CREDENTIAL: "missing-multi-factor-session",
+  SECOND_FACTOR_EXISTS: "second-factor-already-in-use",
+  SECOND_FACTOR_LIMIT_EXCEEDED: "maximum-second-factor-count-exceeded",
+  // Blocking functions related errors.
+  BLOCKING_FUNCTION_ERROR_RESPONSE: "internal-error",
+  // Recaptcha related errors.
+  RECAPTCHA_NOT_ENABLED: "recaptcha-not-enabled",
+  MISSING_RECAPTCHA_TOKEN: "missing-recaptcha-token",
+  INVALID_RECAPTCHA_TOKEN: "invalid-recaptcha-token",
+  INVALID_RECAPTCHA_ACTION: "invalid-recaptcha-action",
+  MISSING_CLIENT_TYPE: "missing-client-type",
+  MISSING_RECAPTCHA_VERSION: "missing-recaptcha-version",
+  INVALID_RECAPTCHA_VERSION: "invalid-recaptcha-version",
+  INVALID_REQ_TYPE: "invalid-req-type"
+  /* AuthErrorCode.INVALID_REQ_TYPE */
+};
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const Mn = new J(3e4, 6e4);
+function he(n, e) {
+  return n.tenantId && !e.tenantId ? Object.assign(Object.assign({}, e), { tenantId: n.tenantId }) : e;
+}
+async function G(n, e, t, i, r = {}) {
+  return Tt(n, r, async () => {
+    let s = {}, o = {};
+    i && (e === "GET" ? o = i : s = {
+      body: JSON.stringify(i)
+    });
+    const c = K(Object.assign({ key: n.config.apiKey }, o)).slice(1), a = await n._getAdditionalHeaders();
+    return a[
+      "Content-Type"
+      /* HttpHeader.CONTENT_TYPE */
+    ] = "application/json", n.languageCode && (a[
+      "X-Firebase-Locale"
+      /* HttpHeader.X_FIREBASE_LOCALE */
+    ] = n.languageCode), It.fetch()(yt(n, n.config.apiHost, t, c), Object.assign({
+      method: e,
+      headers: a,
+      referrerPolicy: "no-referrer"
+    }, s));
+  });
+}
+async function Tt(n, e, t) {
+  n._canInitEmulator = !1;
+  const i = Object.assign(Object.assign({}, Ln), e);
+  try {
+    const r = new Un(n), s = await Promise.race([
+      t(),
+      r.promise
+    ]);
+    r.clearNetworkTimeout();
+    const o = await s.json();
+    if ("needConfirmation" in o)
+      throw ee(n, "account-exists-with-different-credential", o);
+    if (s.ok && !("errorMessage" in o))
+      return o;
+    {
+      const c = s.ok ? o.errorMessage : o.error.message, [a, l] = c.split(" : ");
+      if (a === "FEDERATED_USER_ID_ALREADY_LINKED")
+        throw ee(n, "credential-already-in-use", o);
+      if (a === "EMAIL_EXISTS")
+        throw ee(n, "email-already-in-use", o);
+      if (a === "USER_DISABLED")
+        throw ee(n, "user-disabled", o);
+      const d = i[a] || a.toLowerCase().replace(/[_\s]+/g, "-");
+      if (l)
+        throw vt(n, d, l);
+      S(n, d);
+    }
+  } catch (r) {
+    if (r instanceof Re)
+      throw r;
+    S(n, "network-request-failed", { message: String(r) });
+  }
+}
+async function wt(n, e, t, i, r = {}) {
+  const s = await G(n, e, t, i, r);
+  return "mfaPendingCredential" in s && S(n, "multi-factor-auth-required", {
+    _serverResponse: s
+  }), s;
+}
+function yt(n, e, t, i) {
+  const r = `${e}${t}?${i}`;
+  return n.config.emulator ? Ce(n.config, r) : `${n.config.apiScheme}://${r}`;
+}
+class Un {
+  constructor(e) {
+    this.auth = e, this.timer = null, this.promise = new Promise((t, i) => {
+      this.timer = setTimeout(() => i(I(
+        this.auth,
+        "network-request-failed"
+        /* AuthErrorCode.NETWORK_REQUEST_FAILED */
+      )), Mn.get());
+    });
+  }
+  clearNetworkTimeout() {
+    clearTimeout(this.timer);
+  }
+}
+function ee(n, e, t) {
+  const i = {
+    appName: n.name
+  };
+  t.email && (i.email = t.email), t.phoneNumber && (i.phoneNumber = t.phoneNumber);
+  const r = I(n, e, i);
+  return r.customData._tokenResponse = t, r;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function Dn(n, e) {
+  return G(n, "POST", "/v1/accounts:delete", e);
+}
+async function Et(n, e) {
+  return G(n, "POST", "/v1/accounts:lookup", e);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function B(n) {
+  if (n)
+    try {
+      const e = new Date(Number(n));
+      if (!isNaN(e.getTime()))
+        return e.toUTCString();
+    } catch {
+    }
+}
+async function Fn(n, e = !1) {
+  const t = j(n), i = await t.getIdToken(e), r = Oe(i);
+  u(
+    r && r.exp && r.auth_time && r.iat,
+    t.auth,
+    "internal-error"
+    /* AuthErrorCode.INTERNAL_ERROR */
+  );
+  const s = typeof r.firebase == "object" ? r.firebase : void 0, o = s == null ? void 0 : s.sign_in_provider;
+  return {
+    claims: r,
+    token: i,
+    authTime: B(Te(r.auth_time)),
+    issuedAtTime: B(Te(r.iat)),
+    expirationTime: B(Te(r.exp)),
+    signInProvider: o || null,
+    signInSecondFactor: (s == null ? void 0 : s.sign_in_second_factor) || null
+  };
+}
+function Te(n) {
+  return Number(n) * 1e3;
+}
+function Oe(n) {
+  const [e, t, i] = n.split(".");
+  if (e === void 0 || t === void 0 || i === void 0)
+    return ie("JWT malformed, contained fewer than 3 sections"), null;
+  try {
+    const r = In(t);
+    return r ? JSON.parse(r) : (ie("Failed to decode base64 JWT payload"), null);
+  } catch (r) {
+    return ie("Caught error parsing JWT payload as JSON", r == null ? void 0 : r.toString()), null;
+  }
+}
+function ze(n) {
+  const e = Oe(n);
+  return u(
+    e,
+    "internal-error"
+    /* AuthErrorCode.INTERNAL_ERROR */
+  ), u(
+    typeof e.exp < "u",
+    "internal-error"
+    /* AuthErrorCode.INTERNAL_ERROR */
+  ), u(
+    typeof e.iat < "u",
+    "internal-error"
+    /* AuthErrorCode.INTERNAL_ERROR */
+  ), Number(e.exp) - Number(e.iat);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function q(n, e, t = !1) {
+  if (t)
+    return e;
+  try {
+    return await e;
+  } catch (i) {
+    throw i instanceof Re && xn(i) && n.auth.currentUser === n && await n.auth.signOut(), i;
+  }
+}
+function xn({ code: n }) {
+  return n === "auth/user-disabled" || n === "auth/user-token-expired";
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Vn {
+  constructor(e) {
+    this.user = e, this.isRunning = !1, this.timerId = null, this.errorBackoff = 3e4;
+  }
+  _start() {
+    this.isRunning || (this.isRunning = !0, this.schedule());
+  }
+  _stop() {
+    this.isRunning && (this.isRunning = !1, this.timerId !== null && clearTimeout(this.timerId));
+  }
+  getInterval(e) {
+    var t;
+    if (e) {
+      const i = this.errorBackoff;
+      return this.errorBackoff = Math.min(
+        this.errorBackoff * 2,
+        96e4
+        /* Duration.RETRY_BACKOFF_MAX */
+      ), i;
+    } else {
+      this.errorBackoff = 3e4;
+      const r = ((t = this.user.stsTokenManager.expirationTime) !== null && t !== void 0 ? t : 0) - Date.now() - 3e5;
+      return Math.max(0, r);
+    }
+  }
+  schedule(e = !1) {
+    if (!this.isRunning)
+      return;
+    const t = this.getInterval(e);
+    this.timerId = setTimeout(async () => {
+      await this.iteration();
+    }, t);
+  }
+  async iteration() {
+    try {
+      await this.user.getIdToken(!0);
+    } catch (e) {
+      (e == null ? void 0 : e.code) === "auth/network-request-failed" && this.schedule(
+        /* wasError */
+        !0
+      );
+      return;
+    }
+    this.schedule();
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class ke {
+  constructor(e, t) {
+    this.createdAt = e, this.lastLoginAt = t, this._initializeTime();
+  }
+  _initializeTime() {
+    this.lastSignInTime = B(this.lastLoginAt), this.creationTime = B(this.createdAt);
+  }
+  _copy(e) {
+    this.createdAt = e.createdAt, this.lastLoginAt = e.lastLoginAt, this._initializeTime();
+  }
+  toJSON() {
+    return {
+      createdAt: this.createdAt,
+      lastLoginAt: this.lastLoginAt
+    };
+  }
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function ce(n) {
+  var e;
+  const t = n.auth, i = await n.getIdToken(), r = await q(n, Et(t, { idToken: i }));
+  u(
+    r == null ? void 0 : r.users.length,
+    t,
+    "internal-error"
+    /* AuthErrorCode.INTERNAL_ERROR */
+  );
+  const s = r.users[0];
+  n._notifyReloadListener(s);
+  const o = !((e = s.providerUserInfo) === null || e === void 0) && e.length ? kt(s.providerUserInfo) : [], c = $n(n.providerData, o), a = n.isAnonymous, l = !(n.email && s.passwordHash) && !(c != null && c.length), d = a ? l : !1, h = {
+    uid: s.localId,
+    displayName: s.displayName || null,
+    photoURL: s.photoUrl || null,
+    email: s.email || null,
+    emailVerified: s.emailVerified || !1,
+    phoneNumber: s.phoneNumber || null,
+    tenantId: s.tenantId || null,
+    providerData: c,
+    metadata: new ke(s.createdAt, s.lastLoginAt),
+    isAnonymous: d
+  };
+  Object.assign(n, h);
+}
+async function Hn(n) {
+  const e = j(n);
+  await ce(e), await e.auth._persistUserIfCurrent(e), e.auth._notifyListenersIfCurrent(e);
+}
+function $n(n, e) {
+  return [...n.filter((i) => !e.some((r) => r.providerId === i.providerId)), ...e];
+}
+function kt(n) {
+  return n.map((e) => {
+    var { providerId: t } = e, i = Pe(e, ["providerId"]);
+    return {
+      providerId: t,
+      uid: i.rawId || "",
+      displayName: i.displayName || null,
+      email: i.email || null,
+      phoneNumber: i.phoneNumber || null,
+      photoURL: i.photoUrl || null
+    };
+  });
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function Wn(n, e) {
+  const t = await Tt(n, {}, async () => {
+    const i = K({
+      grant_type: "refresh_token",
+      refresh_token: e
+    }).slice(1), { tokenApiHost: r, apiKey: s } = n.config, o = yt(n, r, "/v1/token", `key=${s}`), c = await n._getAdditionalHeaders();
+    return c[
+      "Content-Type"
+      /* HttpHeader.CONTENT_TYPE */
+    ] = "application/x-www-form-urlencoded", It.fetch()(o, {
+      method: "POST",
+      headers: c,
+      body: i
+    });
+  });
+  return {
+    accessToken: t.access_token,
+    expiresIn: t.expires_in,
+    refreshToken: t.refresh_token
+  };
+}
+async function jn(n, e) {
+  return G(n, "POST", "/v2/accounts:revokeToken", he(n, e));
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class H {
+  constructor() {
+    this.refreshToken = null, this.accessToken = null, this.expirationTime = null;
+  }
+  get isExpired() {
+    return !this.expirationTime || Date.now() > this.expirationTime - 3e4;
+  }
+  updateFromServerResponse(e) {
+    u(
+      e.idToken,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), u(
+      typeof e.idToken < "u",
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), u(
+      typeof e.refreshToken < "u",
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    );
+    const t = "expiresIn" in e && typeof e.expiresIn < "u" ? Number(e.expiresIn) : ze(e.idToken);
+    this.updateTokensAndExpiration(e.idToken, e.refreshToken, t);
+  }
+  updateFromIdToken(e) {
+    u(
+      e.length !== 0,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    );
+    const t = ze(e);
+    this.updateTokensAndExpiration(e, null, t);
+  }
+  async getToken(e, t = !1) {
+    return !t && this.accessToken && !this.isExpired ? this.accessToken : (u(
+      this.refreshToken,
+      e,
+      "user-token-expired"
+      /* AuthErrorCode.TOKEN_EXPIRED */
+    ), this.refreshToken ? (await this.refresh(e, this.refreshToken), this.accessToken) : null);
+  }
+  clearRefreshToken() {
+    this.refreshToken = null;
+  }
+  async refresh(e, t) {
+    const { accessToken: i, refreshToken: r, expiresIn: s } = await Wn(e, t);
+    this.updateTokensAndExpiration(i, r, Number(s));
+  }
+  updateTokensAndExpiration(e, t, i) {
+    this.refreshToken = t || null, this.accessToken = e || null, this.expirationTime = Date.now() + i * 1e3;
+  }
+  static fromJSON(e, t) {
+    const { refreshToken: i, accessToken: r, expirationTime: s } = t, o = new H();
+    return i && (u(typeof i == "string", "internal-error", {
+      appName: e
+    }), o.refreshToken = i), r && (u(typeof r == "string", "internal-error", {
+      appName: e
+    }), o.accessToken = r), s && (u(typeof s == "number", "internal-error", {
+      appName: e
+    }), o.expirationTime = s), o;
+  }
+  toJSON() {
+    return {
+      refreshToken: this.refreshToken,
+      accessToken: this.accessToken,
+      expirationTime: this.expirationTime
+    };
+  }
+  _assign(e) {
+    this.accessToken = e.accessToken, this.refreshToken = e.refreshToken, this.expirationTime = e.expirationTime;
+  }
+  _clone() {
+    return Object.assign(new H(), this.toJSON());
+  }
+  _performRefresh() {
+    return y("not implemented");
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function R(n, e) {
+  u(typeof n == "string" || typeof n > "u", "internal-error", { appName: e });
+}
+class E {
+  constructor(e) {
+    var { uid: t, auth: i, stsTokenManager: r } = e, s = Pe(e, ["uid", "auth", "stsTokenManager"]);
+    this.providerId = "firebase", this.proactiveRefresh = new Vn(this), this.reloadUserInfo = null, this.reloadListener = null, this.uid = t, this.auth = i, this.stsTokenManager = r, this.accessToken = r.accessToken, this.displayName = s.displayName || null, this.email = s.email || null, this.emailVerified = s.emailVerified || !1, this.phoneNumber = s.phoneNumber || null, this.photoURL = s.photoURL || null, this.isAnonymous = s.isAnonymous || !1, this.tenantId = s.tenantId || null, this.providerData = s.providerData ? [...s.providerData] : [], this.metadata = new ke(s.createdAt || void 0, s.lastLoginAt || void 0);
+  }
+  async getIdToken(e) {
+    const t = await q(this, this.stsTokenManager.getToken(this.auth, e));
+    return u(
+      t,
+      this.auth,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), this.accessToken !== t && (this.accessToken = t, await this.auth._persistUserIfCurrent(this), this.auth._notifyListenersIfCurrent(this)), t;
+  }
+  getIdTokenResult(e) {
+    return Fn(this, e);
+  }
+  reload() {
+    return Hn(this);
+  }
+  _assign(e) {
+    this !== e && (u(
+      this.uid === e.uid,
+      this.auth,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), this.displayName = e.displayName, this.photoURL = e.photoURL, this.email = e.email, this.emailVerified = e.emailVerified, this.phoneNumber = e.phoneNumber, this.isAnonymous = e.isAnonymous, this.tenantId = e.tenantId, this.providerData = e.providerData.map((t) => Object.assign({}, t)), this.metadata._copy(e.metadata), this.stsTokenManager._assign(e.stsTokenManager));
+  }
+  _clone(e) {
+    const t = new E(Object.assign(Object.assign({}, this), { auth: e, stsTokenManager: this.stsTokenManager._clone() }));
+    return t.metadata._copy(this.metadata), t;
+  }
+  _onReload(e) {
+    u(
+      !this.reloadListener,
+      this.auth,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), this.reloadListener = e, this.reloadUserInfo && (this._notifyReloadListener(this.reloadUserInfo), this.reloadUserInfo = null);
+  }
+  _notifyReloadListener(e) {
+    this.reloadListener ? this.reloadListener(e) : this.reloadUserInfo = e;
+  }
+  _startProactiveRefresh() {
+    this.proactiveRefresh._start();
+  }
+  _stopProactiveRefresh() {
+    this.proactiveRefresh._stop();
+  }
+  async _updateTokensIfNecessary(e, t = !1) {
+    let i = !1;
+    e.idToken && e.idToken !== this.stsTokenManager.accessToken && (this.stsTokenManager.updateFromServerResponse(e), i = !0), t && await ce(this), await this.auth._persistUserIfCurrent(this), i && this.auth._notifyListenersIfCurrent(this);
+  }
+  async delete() {
+    if (w(this.auth.app))
+      return Promise.reject(L(this.auth));
+    const e = await this.getIdToken();
+    return await q(this, Dn(this.auth, { idToken: e })), this.stsTokenManager.clearRefreshToken(), this.auth.signOut();
+  }
+  toJSON() {
+    return Object.assign(Object.assign({
+      uid: this.uid,
+      email: this.email || void 0,
+      emailVerified: this.emailVerified,
+      displayName: this.displayName || void 0,
+      isAnonymous: this.isAnonymous,
+      photoURL: this.photoURL || void 0,
+      phoneNumber: this.phoneNumber || void 0,
+      tenantId: this.tenantId || void 0,
+      providerData: this.providerData.map((e) => Object.assign({}, e)),
+      stsTokenManager: this.stsTokenManager.toJSON(),
+      // Redirect event ID must be maintained in case there is a pending
+      // redirect event.
+      _redirectEventId: this._redirectEventId
+    }, this.metadata.toJSON()), {
+      // Required for compatibility with the legacy SDK (go/firebase-auth-sdk-persistence-parsing):
+      apiKey: this.auth.config.apiKey,
+      appName: this.auth.name
+    });
+  }
+  get refreshToken() {
+    return this.stsTokenManager.refreshToken || "";
+  }
+  static _fromJSON(e, t) {
+    var i, r, s, o, c, a, l, d;
+    const h = (i = t.displayName) !== null && i !== void 0 ? i : void 0, g = (r = t.email) !== null && r !== void 0 ? r : void 0, F = (s = t.phoneNumber) !== null && s !== void 0 ? s : void 0, M = (o = t.photoURL) !== null && o !== void 0 ? o : void 0, p = (c = t.tenantId) !== null && c !== void 0 ? c : void 0, _ = (a = t._redirectEventId) !== null && a !== void 0 ? a : void 0, v = (l = t.createdAt) !== null && l !== void 0 ? l : void 0, x = (d = t.lastLoginAt) !== null && d !== void 0 ? d : void 0, { uid: _e, emailVerified: De, isAnonymous: Fe, providerData: ve, stsTokenManager: xe } = t;
+    u(
+      _e && xe,
+      e,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    );
+    const Kt = H.fromJSON(this.name, xe);
+    u(
+      typeof _e == "string",
+      e,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), R(h, e.name), R(g, e.name), u(
+      typeof De == "boolean",
+      e,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), u(
+      typeof Fe == "boolean",
+      e,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), R(F, e.name), R(M, e.name), R(p, e.name), R(_, e.name), R(v, e.name), R(x, e.name);
+    const Ie = new E({
+      uid: _e,
+      auth: e,
+      email: g,
+      emailVerified: De,
+      displayName: h,
+      isAnonymous: Fe,
+      photoURL: M,
+      phoneNumber: F,
+      tenantId: p,
+      stsTokenManager: Kt,
+      createdAt: v,
+      lastLoginAt: x
+    });
+    return ve && Array.isArray(ve) && (Ie.providerData = ve.map((Jt) => Object.assign({}, Jt))), _ && (Ie._redirectEventId = _), Ie;
+  }
+  /**
+   * Initialize a User from an idToken server response
+   * @param auth
+   * @param idTokenResponse
+   */
+  static async _fromIdTokenResponse(e, t, i = !1) {
+    const r = new H();
+    r.updateFromServerResponse(t);
+    const s = new E({
+      uid: t.localId,
+      auth: e,
+      stsTokenManager: r,
+      isAnonymous: i
+    });
+    return await ce(s), s;
+  }
+  /**
+   * Initialize a User from an idToken server response
+   * @param auth
+   * @param idTokenResponse
+   */
+  static async _fromGetAccountInfoResponse(e, t, i) {
+    const r = t.users[0];
+    u(
+      r.localId !== void 0,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    );
+    const s = r.providerUserInfo !== void 0 ? kt(r.providerUserInfo) : [], o = !(r.email && r.passwordHash) && !(s != null && s.length), c = new H();
+    c.updateFromIdToken(i);
+    const a = new E({
+      uid: r.localId,
+      auth: e,
+      stsTokenManager: c,
+      isAnonymous: o
+    }), l = {
+      uid: r.localId,
+      displayName: r.displayName || null,
+      photoURL: r.photoUrl || null,
+      email: r.email || null,
+      emailVerified: r.emailVerified || !1,
+      phoneNumber: r.phoneNumber || null,
+      tenantId: r.tenantId || null,
+      providerData: s,
+      metadata: new ke(r.createdAt, r.lastLoginAt),
+      isAnonymous: !(r.email && r.passwordHash) && !(s != null && s.length)
+    };
+    return Object.assign(a, l), a;
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const Ke = /* @__PURE__ */ new Map();
+function k(n) {
+  b(n instanceof Function, "Expected a class definition");
+  let e = Ke.get(n);
+  return e ? (b(e instanceof n, "Instance stored in cache mismatched with class"), e) : (e = new n(), Ke.set(n, e), e);
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class St {
+  constructor() {
+    this.type = "NONE", this.storage = {};
+  }
+  async _isAvailable() {
+    return !0;
+  }
+  async _set(e, t) {
+    this.storage[e] = t;
+  }
+  async _get(e) {
+    const t = this.storage[e];
+    return t === void 0 ? null : t;
+  }
+  async _remove(e) {
+    delete this.storage[e];
+  }
+  _addListener(e, t) {
+  }
+  _removeListener(e, t) {
+  }
+}
+St.type = "NONE";
+const Je = St;
+/**
+ * @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 re(n, e, t) {
+  return `firebase:${n}:${e}:${t}`;
+}
+class $ {
+  constructor(e, t, i) {
+    this.persistence = e, this.auth = t, this.userKey = i;
+    const { config: r, name: s } = this.auth;
+    this.fullUserKey = re(this.userKey, r.apiKey, s), this.fullPersistenceKey = re("persistence", r.apiKey, s), this.boundEventHandler = t._onStorageEvent.bind(t), this.persistence._addListener(this.fullUserKey, this.boundEventHandler);
+  }
+  setCurrentUser(e) {
+    return this.persistence._set(this.fullUserKey, e.toJSON());
+  }
+  async getCurrentUser() {
+    const e = await this.persistence._get(this.fullUserKey);
+    return e ? E._fromJSON(this.auth, e) : null;
+  }
+  removeCurrentUser() {
+    return this.persistence._remove(this.fullUserKey);
+  }
+  savePersistenceForRedirect() {
+    return this.persistence._set(this.fullPersistenceKey, this.persistence.type);
+  }
+  async setPersistence(e) {
+    if (this.persistence === e)
+      return;
+    const t = await this.getCurrentUser();
+    if (await this.removeCurrentUser(), this.persistence = e, t)
+      return this.setCurrentUser(t);
+  }
+  delete() {
+    this.persistence._removeListener(this.fullUserKey, this.boundEventHandler);
+  }
+  static async create(e, t, i = "authUser") {
+    if (!t.length)
+      return new $(k(Je), e, i);
+    const r = (await Promise.all(t.map(async (l) => {
+      if (await l._isAvailable())
+        return l;
+    }))).filter((l) => l);
+    let s = r[0] || k(Je);
+    const o = re(i, e.config.apiKey, e.name);
+    let c = null;
+    for (const l of t)
+      try {
+        const d = await l._get(o);
+        if (d) {
+          const h = E._fromJSON(e, d);
+          l !== s && (c = h), s = l;
+          break;
+        }
+      } catch {
+      }
+    const a = r.filter((l) => l._shouldAllowMigration);
+    return !s._shouldAllowMigration || !a.length ? new $(s, e, i) : (s = a[0], c && await s._set(o, c.toJSON()), await Promise.all(t.map(async (l) => {
+      if (l !== s)
+        try {
+          await l._remove(o);
+        } catch {
+        }
+    })), new $(s, e, i));
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function Ye(n) {
+  const e = n.toLowerCase();
+  if (e.includes("opera/") || e.includes("opr/") || e.includes("opios/"))
+    return "Opera";
+  if (Pt(e))
+    return "IEMobile";
+  if (e.includes("msie") || e.includes("trident/"))
+    return "IE";
+  if (e.includes("edge/"))
+    return "Edge";
+  if (bt(e))
+    return "Firefox";
+  if (e.includes("silk/"))
+    return "Silk";
+  if (Ct(e))
+    return "Blackberry";
+  if (Ot(e))
+    return "Webos";
+  if (Ne(e))
+    return "Safari";
+  if ((e.includes("chrome/") || Rt(e)) && !e.includes("edge/"))
+    return "Chrome";
+  if (At(e))
+    return "Android";
+  {
+    const t = /([a-zA-Z\d\.]+)\/[a-zA-Z\d\.]*$/, i = n.match(t);
+    if ((i == null ? void 0 : i.length) === 2)
+      return i[1];
+  }
+  return "Other";
+}
+function bt(n = m()) {
+  return /firefox\//i.test(n);
+}
+function Ne(n = m()) {
+  const e = n.toLowerCase();
+  return e.includes("safari/") && !e.includes("chrome/") && !e.includes("crios/") && !e.includes("android");
+}
+function Rt(n = m()) {
+  return /crios\//i.test(n);
+}
+function Pt(n = m()) {
+  return /iemobile/i.test(n);
+}
+function At(n = m()) {
+  return /android/i.test(n);
+}
+function Ct(n = m()) {
+  return /blackberry/i.test(n);
+}
+function Ot(n = m()) {
+  return /webos/i.test(n);
+}
+function fe(n = m()) {
+  return /iphone|ipad|ipod/i.test(n) || /macintosh/i.test(n) && /mobile/i.test(n);
+}
+function Gn(n = m()) {
+  var e;
+  return fe(n) && !!(!((e = window.navigator) === null || e === void 0) && e.standalone);
+}
+function Bn() {
+  return Tn() && document.documentMode === 10;
+}
+function Nt(n = m()) {
+  return fe(n) || At(n) || Ot(n) || Ct(n) || /windows phone/i.test(n) || Pt(n);
+}
+function qn() {
+  try {
+    return !!(window && window !== window.top);
+  } catch {
+    return !1;
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function Lt(n, e = []) {
+  let t;
+  switch (n) {
+    case "Browser":
+      t = Ye(m());
+      break;
+    case "Worker":
+      t = `${Ye(m())}-${n}`;
+      break;
+    default:
+      t = n;
+  }
+  const i = e.length ? e.join(",") : "FirebaseCore-web";
+  return `${t}/JsCore/${z}/${i}`;
+}
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class zn {
+  constructor(e) {
+    this.auth = e, this.queue = [];
+  }
+  pushCallback(e, t) {
+    const i = (s) => new Promise((o, c) => {
+      try {
+        const a = e(s);
+        o(a);
+      } catch (a) {
+        c(a);
+      }
+    });
+    i.onAbort = t, this.queue.push(i);
+    const r = this.queue.length - 1;
+    return () => {
+      this.queue[r] = () => Promise.resolve();
+    };
+  }
+  async runMiddleware(e) {
+    if (this.auth.currentUser === e)
+      return;
+    const t = [];
+    try {
+      for (const i of this.queue)
+        await i(e), i.onAbort && t.push(i.onAbort);
+    } catch (i) {
+      t.reverse();
+      for (const r of t)
+        try {
+          r();
+        } catch {
+        }
+      throw this.auth._errorFactory.create("login-blocked", {
+        originalMessage: i == null ? void 0 : i.message
+      });
+    }
+  }
+}
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function Kn(n, e = {}) {
+  return G(n, "GET", "/v2/passwordPolicy", he(n, e));
+}
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const Jn = 6;
+class Yn {
+  constructor(e) {
+    var t, i, r, s;
+    const o = e.customStrengthOptions;
+    this.customStrengthOptions = {}, this.customStrengthOptions.minPasswordLength = (t = o.minPasswordLength) !== null && t !== void 0 ? t : Jn, o.maxPasswordLength && (this.customStrengthOptions.maxPasswordLength = o.maxPasswordLength), o.containsLowercaseCharacter !== void 0 && (this.customStrengthOptions.containsLowercaseLetter = o.containsLowercaseCharacter), o.containsUppercaseCharacter !== void 0 && (this.customStrengthOptions.containsUppercaseLetter = o.containsUppercaseCharacter), o.containsNumericCharacter !== void 0 && (this.customStrengthOptions.containsNumericCharacter = o.containsNumericCharacter), o.containsNonAlphanumericCharacter !== void 0 && (this.customStrengthOptions.containsNonAlphanumericCharacter = o.containsNonAlphanumericCharacter), this.enforcementState = e.enforcementState, this.enforcementState === "ENFORCEMENT_STATE_UNSPECIFIED" && (this.enforcementState = "OFF"), this.allowedNonAlphanumericCharacters = (r = (i = e.allowedNonAlphanumericCharacters) === null || i === void 0 ? void 0 : i.join("")) !== null && r !== void 0 ? r : "", this.forceUpgradeOnSignin = (s = e.forceUpgradeOnSignin) !== null && s !== void 0 ? s : !1, this.schemaVersion = e.schemaVersion;
+  }
+  validatePassword(e) {
+    var t, i, r, s, o, c;
+    const a = {
+      isValid: !0,
+      passwordPolicy: this
+    };
+    return this.validatePasswordLengthOptions(e, a), this.validatePasswordCharacterOptions(e, a), a.isValid && (a.isValid = (t = a.meetsMinPasswordLength) !== null && t !== void 0 ? t : !0), a.isValid && (a.isValid = (i = a.meetsMaxPasswordLength) !== null && i !== void 0 ? i : !0), a.isValid && (a.isValid = (r = a.containsLowercaseLetter) !== null && r !== void 0 ? r : !0), a.isValid && (a.isValid = (s = a.containsUppercaseLetter) !== null && s !== void 0 ? s : !0), a.isValid && (a.isValid = (o = a.containsNumericCharacter) !== null && o !== void 0 ? o : !0), a.isValid && (a.isValid = (c = a.containsNonAlphanumericCharacter) !== null && c !== void 0 ? c : !0), a;
+  }
+  /**
+   * Validates that the password meets the length options for the policy.
+   *
+   * @param password Password to validate.
+   * @param status Validation status.
+   */
+  validatePasswordLengthOptions(e, t) {
+    const i = this.customStrengthOptions.minPasswordLength, r = this.customStrengthOptions.maxPasswordLength;
+    i && (t.meetsMinPasswordLength = e.length >= i), r && (t.meetsMaxPasswordLength = e.length <= r);
+  }
+  /**
+   * Validates that the password meets the character options for the policy.
+   *
+   * @param password Password to validate.
+   * @param status Validation status.
+   */
+  validatePasswordCharacterOptions(e, t) {
+    this.updatePasswordCharacterOptionsStatuses(
+      t,
+      /* containsLowercaseCharacter= */
+      !1,
+      /* containsUppercaseCharacter= */
+      !1,
+      /* containsNumericCharacter= */
+      !1,
+      /* containsNonAlphanumericCharacter= */
+      !1
+    );
+    let i;
+    for (let r = 0; r < e.length; r++)
+      i = e.charAt(r), this.updatePasswordCharacterOptionsStatuses(
+        t,
+        /* containsLowercaseCharacter= */
+        i >= "a" && i <= "z",
+        /* containsUppercaseCharacter= */
+        i >= "A" && i <= "Z",
+        /* containsNumericCharacter= */
+        i >= "0" && i <= "9",
+        /* containsNonAlphanumericCharacter= */
+        this.allowedNonAlphanumericCharacters.includes(i)
+      );
+  }
+  /**
+   * Updates the running validation status with the statuses for the character options.
+   * Expected to be called each time a character is processed to update each option status
+   * based on the current character.
+   *
+   * @param status Validation status.
+   * @param containsLowercaseCharacter Whether the character is a lowercase letter.
+   * @param containsUppercaseCharacter Whether the character is an uppercase letter.
+   * @param containsNumericCharacter Whether the character is a numeric character.
+   * @param containsNonAlphanumericCharacter Whether the character is a non-alphanumeric character.
+   */
+  updatePasswordCharacterOptionsStatuses(e, t, i, r, s) {
+    this.customStrengthOptions.containsLowercaseLetter && (e.containsLowercaseLetter || (e.containsLowercaseLetter = t)), this.customStrengthOptions.containsUppercaseLetter && (e.containsUppercaseLetter || (e.containsUppercaseLetter = i)), this.customStrengthOptions.containsNumericCharacter && (e.containsNumericCharacter || (e.containsNumericCharacter = r)), this.customStrengthOptions.containsNonAlphanumericCharacter && (e.containsNonAlphanumericCharacter || (e.containsNonAlphanumericCharacter = s));
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Xn {
+  constructor(e, t, i, r) {
+    this.app = e, this.heartbeatServiceProvider = t, this.appCheckServiceProvider = i, this.config = r, this.currentUser = null, this.emulatorConfig = null, this.operations = Promise.resolve(), this.authStateSubscription = new Xe(this), this.idTokenSubscription = new Xe(this), this.beforeStateQueue = new zn(this), this.redirectUser = null, this.isProactiveRefreshEnabled = !1, this.EXPECTED_PASSWORD_POLICY_SCHEMA_VERSION = 1, this._canInitEmulator = !0, this._isInitialized = !1, this._deleted = !1, this._initializationPromise = null, this._popupRedirectResolver = null, this._errorFactory = _t, this._agentRecaptchaConfig = null, this._tenantRecaptchaConfigs = {}, this._projectPasswordPolicy = null, this._tenantPasswordPolicies = {}, this.lastNotifiedUid = void 0, this.languageCode = null, this.tenantId = null, this.settings = { appVerificationDisabledForTesting: !1 }, this.frameworks = [], this.name = e.name, this.clientVersion = r.sdkClientVersion;
+  }
+  _initializeWithPersistence(e, t) {
+    return t && (this._popupRedirectResolver = k(t)), this._initializationPromise = this.queue(async () => {
+      var i, r;
+      if (!this._deleted && (this.persistenceManager = await $.create(this, e), !this._deleted)) {
+        if (!((i = this._popupRedirectResolver) === null || i === void 0) && i._shouldInitProactively)
+          try {
+            await this._popupRedirectResolver._initialize(this);
+          } catch {
+          }
+        await this.initializeCurrentUser(t), this.lastNotifiedUid = ((r = this.currentUser) === null || r === void 0 ? void 0 : r.uid) || null, !this._deleted && (this._isInitialized = !0);
+      }
+    }), this._initializationPromise;
+  }
+  /**
+   * If the persistence is changed in another window, the user manager will let us know
+   */
+  async _onStorageEvent() {
+    if (this._deleted)
+      return;
+    const e = await this.assertedPersistence.getCurrentUser();
+    if (!(!this.currentUser && !e)) {
+      if (this.currentUser && e && this.currentUser.uid === e.uid) {
+        this._currentUser._assign(e), await this.currentUser.getIdToken();
+        return;
+      }
+      await this._updateCurrentUser(
+        e,
+        /* skipBeforeStateCallbacks */
+        !0
+      );
+    }
+  }
+  async initializeCurrentUserFromIdToken(e) {
+    try {
+      const t = await Et(this, { idToken: e }), i = await E._fromGetAccountInfoResponse(this, t, e);
+      await this.directlySetCurrentUser(i);
+    } catch (t) {
+      console.warn("FirebaseServerApp could not login user with provided authIdToken: ", t), await this.directlySetCurrentUser(null);
+    }
+  }
+  async initializeCurrentUser(e) {
+    var t;
+    if (w(this.app)) {
+      const o = this.app.settings.authIdToken;
+      return o ? new Promise((c) => {
+        setTimeout(() => this.initializeCurrentUserFromIdToken(o).then(c, c));
+      }) : this.directlySetCurrentUser(null);
+    }
+    const i = await this.assertedPersistence.getCurrentUser();
+    let r = i, s = !1;
+    if (e && this.config.authDomain) {
+      await this.getOrInitRedirectPersistenceManager();
+      const o = (t = this.redirectUser) === null || t === void 0 ? void 0 : t._redirectEventId, c = r == null ? void 0 : r._redirectEventId, a = await this.tryRedirectSignIn(e);
+      (!o || o === c) && (a != null && a.user) && (r = a.user, s = !0);
+    }
+    if (!r)
+      return this.directlySetCurrentUser(null);
+    if (!r._redirectEventId) {
+      if (s)
+        try {
+          await this.beforeStateQueue.runMiddleware(r);
+        } catch (o) {
+          r = i, this._popupRedirectResolver._overrideRedirectResult(this, () => Promise.reject(o));
+        }
+      return r ? this.reloadAndSetCurrentUserOrClear(r) : this.directlySetCurrentUser(null);
+    }
+    return u(
+      this._popupRedirectResolver,
+      this,
+      "argument-error"
+      /* AuthErrorCode.ARGUMENT_ERROR */
+    ), await this.getOrInitRedirectPersistenceManager(), this.redirectUser && this.redirectUser._redirectEventId === r._redirectEventId ? this.directlySetCurrentUser(r) : this.reloadAndSetCurrentUserOrClear(r);
+  }
+  async tryRedirectSignIn(e) {
+    let t = null;
+    try {
+      t = await this._popupRedirectResolver._completeRedirectFn(this, e, !0);
+    } catch {
+      await this._setRedirectUser(null);
+    }
+    return t;
+  }
+  async reloadAndSetCurrentUserOrClear(e) {
+    try {
+      await ce(e);
+    } catch (t) {
+      if ((t == null ? void 0 : t.code) !== "auth/network-request-failed")
+        return this.directlySetCurrentUser(null);
+    }
+    return this.directlySetCurrentUser(e);
+  }
+  useDeviceLanguage() {
+    this.languageCode = Nn();
+  }
+  async _delete() {
+    this._deleted = !0;
+  }
+  async updateCurrentUser(e) {
+    if (w(this.app))
+      return Promise.reject(L(this));
+    const t = e ? j(e) : null;
+    return t && u(
+      t.auth.config.apiKey === this.config.apiKey,
+      this,
+      "invalid-user-token"
+      /* AuthErrorCode.INVALID_AUTH */
+    ), this._updateCurrentUser(t && t._clone(this));
+  }
+  async _updateCurrentUser(e, t = !1) {
+    if (!this._deleted)
+      return e && u(
+        this.tenantId === e.tenantId,
+        this,
+        "tenant-id-mismatch"
+        /* AuthErrorCode.TENANT_ID_MISMATCH */
+      ), t || await this.beforeStateQueue.runMiddleware(e), this.queue(async () => {
+        await this.directlySetCurrentUser(e), this.notifyAuthListeners();
+      });
+  }
+  async signOut() {
+    return w(this.app) ? Promise.reject(L(this)) : (await this.beforeStateQueue.runMiddleware(null), (this.redirectPersistenceManager || this._popupRedirectResolver) && await this._setRedirectUser(null), this._updateCurrentUser(
+      null,
+      /* skipBeforeStateCallbacks */
+      !0
+    ));
+  }
+  setPersistence(e) {
+    return w(this.app) ? Promise.reject(L(this)) : this.queue(async () => {
+      await this.assertedPersistence.setPersistence(k(e));
+    });
+  }
+  _getRecaptchaConfig() {
+    return this.tenantId == null ? this._agentRecaptchaConfig : this._tenantRecaptchaConfigs[this.tenantId];
+  }
+  async validatePassword(e) {
+    this._getPasswordPolicyInternal() || await this._updatePasswordPolicy();
+    const t = this._getPasswordPolicyInternal();
+    return t.schemaVersion !== this.EXPECTED_PASSWORD_POLICY_SCHEMA_VERSION ? Promise.reject(this._errorFactory.create("unsupported-password-policy-schema-version", {})) : t.validatePassword(e);
+  }
+  _getPasswordPolicyInternal() {
+    return this.tenantId === null ? this._projectPasswordPolicy : this._tenantPasswordPolicies[this.tenantId];
+  }
+  async _updatePasswordPolicy() {
+    const e = await Kn(this), t = new Yn(e);
+    this.tenantId === null ? this._projectPasswordPolicy = t : this._tenantPasswordPolicies[this.tenantId] = t;
+  }
+  _getPersistence() {
+    return this.assertedPersistence.persistence.type;
+  }
+  _updateErrorMap(e) {
+    this._errorFactory = new be("auth", "Firebase", e());
+  }
+  onAuthStateChanged(e, t, i) {
+    return this.registerStateListener(this.authStateSubscription, e, t, i);
+  }
+  beforeAuthStateChanged(e, t) {
+    return this.beforeStateQueue.pushCallback(e, t);
+  }
+  onIdTokenChanged(e, t, i) {
+    return this.registerStateListener(this.idTokenSubscription, e, t, i);
+  }
+  authStateReady() {
+    return new Promise((e, t) => {
+      if (this.currentUser)
+        e();
+      else {
+        const i = this.onAuthStateChanged(() => {
+          i(), e();
+        }, t);
+      }
+    });
+  }
+  /**
+   * Revokes the given access token. Currently only supports Apple OAuth access tokens.
+   */
+  async revokeAccessToken(e) {
+    if (this.currentUser) {
+      const t = await this.currentUser.getIdToken(), i = {
+        providerId: "apple.com",
+        tokenType: "ACCESS_TOKEN",
+        token: e,
+        idToken: t
+      };
+      this.tenantId != null && (i.tenantId = this.tenantId), await jn(this, i);
+    }
+  }
+  toJSON() {
+    var e;
+    return {
+      apiKey: this.config.apiKey,
+      authDomain: this.config.authDomain,
+      appName: this.name,
+      currentUser: (e = this._currentUser) === null || e === void 0 ? void 0 : e.toJSON()
+    };
+  }
+  async _setRedirectUser(e, t) {
+    const i = await this.getOrInitRedirectPersistenceManager(t);
+    return e === null ? i.removeCurrentUser() : i.setCurrentUser(e);
+  }
+  async getOrInitRedirectPersistenceManager(e) {
+    if (!this.redirectPersistenceManager) {
+      const t = e && k(e) || this._popupRedirectResolver;
+      u(
+        t,
+        this,
+        "argument-error"
+        /* AuthErrorCode.ARGUMENT_ERROR */
+      ), this.redirectPersistenceManager = await $.create(
+        this,
+        [k(t._redirectPersistence)],
+        "redirectUser"
+        /* KeyName.REDIRECT_USER */
+      ), this.redirectUser = await this.redirectPersistenceManager.getCurrentUser();
+    }
+    return this.redirectPersistenceManager;
+  }
+  async _redirectUserForId(e) {
+    var t, i;
+    return this._isInitialized && await this.queue(async () => {
+    }), ((t = this._currentUser) === null || t === void 0 ? void 0 : t._redirectEventId) === e ? this._currentUser : ((i = this.redirectUser) === null || i === void 0 ? void 0 : i._redirectEventId) === e ? this.redirectUser : null;
+  }
+  async _persistUserIfCurrent(e) {
+    if (e === this.currentUser)
+      return this.queue(async () => this.directlySetCurrentUser(e));
+  }
+  /** Notifies listeners only if the user is current */
+  _notifyListenersIfCurrent(e) {
+    e === this.currentUser && this.notifyAuthListeners();
+  }
+  _key() {
+    return `${this.config.authDomain}:${this.config.apiKey}:${this.name}`;
+  }
+  _startProactiveRefresh() {
+    this.isProactiveRefreshEnabled = !0, this.currentUser && this._currentUser._startProactiveRefresh();
+  }
+  _stopProactiveRefresh() {
+    this.isProactiveRefreshEnabled = !1, this.currentUser && this._currentUser._stopProactiveRefresh();
+  }
+  /** Returns the current user cast as the internal type */
+  get _currentUser() {
+    return this.currentUser;
+  }
+  notifyAuthListeners() {
+    var e, t;
+    if (!this._isInitialized)
+      return;
+    this.idTokenSubscription.next(this.currentUser);
+    const i = (t = (e = this.currentUser) === null || e === void 0 ? void 0 : e.uid) !== null && t !== void 0 ? t : null;
+    this.lastNotifiedUid !== i && (this.lastNotifiedUid = i, this.authStateSubscription.next(this.currentUser));
+  }
+  registerStateListener(e, t, i, r) {
+    if (this._deleted)
+      return () => {
+      };
+    const s = typeof t == "function" ? t : t.next.bind(t);
+    let o = !1;
+    const c = this._isInitialized ? Promise.resolve() : this._initializationPromise;
+    if (u(
+      c,
+      this,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), c.then(() => {
+      o || s(this.currentUser);
+    }), typeof t == "function") {
+      const a = e.addObserver(t, i, r);
+      return () => {
+        o = !0, a();
+      };
+    } else {
+      const a = e.addObserver(t);
+      return () => {
+        o = !0, a();
+      };
+    }
+  }
+  /**
+   * Unprotected (from race conditions) method to set the current user. This
+   * should only be called from within a queued callback. This is necessary
+   * because the queue shouldn't rely on another queued callback.
+   */
+  async directlySetCurrentUser(e) {
+    this.currentUser && this.currentUser !== e && this._currentUser._stopProactiveRefresh(), e && this.isProactiveRefreshEnabled && e._startProactiveRefresh(), this.currentUser = e, e ? await this.assertedPersistence.setCurrentUser(e) : await this.assertedPersistence.removeCurrentUser();
+  }
+  queue(e) {
+    return this.operations = this.operations.then(e, e), this.operations;
+  }
+  get assertedPersistence() {
+    return u(
+      this.persistenceManager,
+      this,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), this.persistenceManager;
+  }
+  _logFramework(e) {
+    !e || this.frameworks.includes(e) || (this.frameworks.push(e), this.frameworks.sort(), this.clientVersion = Lt(this.config.clientPlatform, this._getFrameworks()));
+  }
+  _getFrameworks() {
+    return this.frameworks;
+  }
+  async _getAdditionalHeaders() {
+    var e;
+    const t = {
+      "X-Client-Version": this.clientVersion
+    };
+    this.app.options.appId && (t[
+      "X-Firebase-gmpid"
+      /* HttpHeader.X_FIREBASE_GMPID */
+    ] = this.app.options.appId);
+    const i = await ((e = this.heartbeatServiceProvider.getImmediate({
+      optional: !0
+    })) === null || e === void 0 ? void 0 : e.getHeartbeatsHeader());
+    i && (t[
+      "X-Firebase-Client"
+      /* HttpHeader.X_FIREBASE_CLIENT */
+    ] = i);
+    const r = await this._getAppCheckToken();
+    return r && (t[
+      "X-Firebase-AppCheck"
+      /* HttpHeader.X_FIREBASE_APP_CHECK */
+    ] = r), t;
+  }
+  async _getAppCheckToken() {
+    var e;
+    const t = await ((e = this.appCheckServiceProvider.getImmediate({ optional: !0 })) === null || e === void 0 ? void 0 : e.getToken());
+    return t != null && t.error && An(`Error while retrieving App Check token: ${t.error}`), t == null ? void 0 : t.token;
+  }
+}
+function pe(n) {
+  return j(n);
+}
+class Xe {
+  constructor(e) {
+    this.auth = e, this.observer = null, this.addObserver = mn((t) => this.observer = t);
+  }
+  get next() {
+    return u(
+      this.observer,
+      this.auth,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), this.observer.next.bind(this.observer);
+  }
+}
+/**
+ * @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.
+ */
+let Le = {
+  async loadJS() {
+    throw new Error("Unable to load external scripts");
+  },
+  recaptchaV2Script: "",
+  recaptchaEnterpriseScript: "",
+  gapiScript: ""
+};
+function Qn(n) {
+  Le = n;
+}
+function Zn(n) {
+  return Le.loadJS(n);
+}
+function ei() {
+  return Le.gapiScript;
+}
+function ti(n) {
+  return `__${n}${Math.floor(Math.random() * 1e6)}`;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function ni(n, e) {
+  const t = pt(n, "auth");
+  if (t.isInitialized()) {
+    const r = t.getImmediate(), s = t.getOptions();
+    if (vn(s, e ?? {}))
+      return r;
+    S(
+      r,
+      "already-initialized"
+      /* AuthErrorCode.ALREADY_INITIALIZED */
+    );
+  }
+  return t.initialize({ options: e });
+}
+function ii(n, e) {
+  const t = (e == null ? void 0 : e.persistence) || [], i = (Array.isArray(t) ? t : [t]).map(k);
+  e != null && e.errorMap && n._updateErrorMap(e.errorMap), n._initializeWithPersistence(i, e == null ? void 0 : e.popupRedirectResolver);
+}
+function ri(n, e, t) {
+  const i = pe(n);
+  u(
+    i._canInitEmulator,
+    i,
+    "emulator-config-failed"
+    /* AuthErrorCode.EMULATOR_CONFIG_FAILED */
+  ), u(
+    /^https?:\/\//.test(e),
+    i,
+    "invalid-emulator-scheme"
+    /* AuthErrorCode.INVALID_EMULATOR_SCHEME */
+  );
+  const r = !1, s = Mt(e), { host: o, port: c } = si(e), a = c === null ? "" : `:${c}`;
+  i.config.emulator = { url: `${s}//${o}${a}/` }, i.settings.appVerificationDisabledForTesting = !0, i.emulatorConfig = Object.freeze({
+    host: o,
+    port: c,
+    protocol: s.replace(":", ""),
+    options: Object.freeze({ disableWarnings: r })
+  }), oi();
+}
+function Mt(n) {
+  const e = n.indexOf(":");
+  return e < 0 ? "" : n.substr(0, e + 1);
+}
+function si(n) {
+  const e = Mt(n), t = /(\/\/)?([^?#/]+)/.exec(n.substr(e.length));
+  if (!t)
+    return { host: "", port: null };
+  const i = t[2].split("@").pop() || "", r = /^(\[[^\]]+\])(:|$)/.exec(i);
+  if (r) {
+    const s = r[1];
+    return { host: s, port: Qe(i.substr(s.length + 1)) };
+  } else {
+    const [s, o] = i.split(":");
+    return { host: s, port: Qe(o) };
+  }
+}
+function Qe(n) {
+  if (!n)
+    return null;
+  const e = Number(n);
+  return isNaN(e) ? null : e;
+}
+function oi() {
+  function n() {
+    const e = document.createElement("p"), t = e.style;
+    e.innerText = "Running in emulator mode. Do not use with production credentials.", t.position = "fixed", t.width = "100%", t.backgroundColor = "#ffffff", t.border = ".1em solid #000000", t.color = "#b50000", t.bottom = "0px", t.left = "0px", t.margin = "0px", t.zIndex = "10000", t.textAlign = "center", e.classList.add("firebase-emulator-warning"), document.body.appendChild(e);
+  }
+  typeof console < "u" && typeof console.info == "function" && console.info("WARNING: You are using the Auth Emulator, which is intended for local testing only.  Do not use with production credentials."), typeof window < "u" && typeof document < "u" && (document.readyState === "loading" ? window.addEventListener("DOMContentLoaded", n) : n());
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Ut {
+  /** @internal */
+  constructor(e, t) {
+    this.providerId = e, this.signInMethod = t;
+  }
+  /**
+   * Returns a JSON-serializable representation of this object.
+   *
+   * @returns a JSON-serializable representation of this object.
+   */
+  toJSON() {
+    return y("not implemented");
+  }
+  /** @internal */
+  _getIdTokenResponse(e) {
+    return y("not implemented");
+  }
+  /** @internal */
+  _linkToIdToken(e, t) {
+    return y("not implemented");
+  }
+  /** @internal */
+  _getReauthenticationResolver(e) {
+    return y("not implemented");
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function W(n, e) {
+  return wt(n, "POST", "/v1/accounts:signInWithIdp", he(n, e));
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const ai = "http://localhost";
+class U extends Ut {
+  constructor() {
+    super(...arguments), this.pendingToken = null;
+  }
+  /** @internal */
+  static _fromParams(e) {
+    const t = new U(e.providerId, e.signInMethod);
+    return e.idToken || e.accessToken ? (e.idToken && (t.idToken = e.idToken), e.accessToken && (t.accessToken = e.accessToken), e.nonce && !e.pendingToken && (t.nonce = e.nonce), e.pendingToken && (t.pendingToken = e.pendingToken)) : e.oauthToken && e.oauthTokenSecret ? (t.accessToken = e.oauthToken, t.secret = e.oauthTokenSecret) : S(
+      "argument-error"
+      /* AuthErrorCode.ARGUMENT_ERROR */
+    ), t;
+  }
+  /** {@inheritdoc AuthCredential.toJSON}  */
+  toJSON() {
+    return {
+      idToken: this.idToken,
+      accessToken: this.accessToken,
+      secret: this.secret,
+      nonce: this.nonce,
+      pendingToken: this.pendingToken,
+      providerId: this.providerId,
+      signInMethod: this.signInMethod
+    };
+  }
+  /**
+   * Static method to deserialize a JSON representation of an object into an
+   * {@link  AuthCredential}.
+   *
+   * @param json - Input can be either Object or the stringified representation of the object.
+   * When string is provided, JSON.parse would be called first.
+   *
+   * @returns If the JSON input does not represent an {@link  AuthCredential}, null is returned.
+   */
+  static fromJSON(e) {
+    const t = typeof e == "string" ? JSON.parse(e) : e, { providerId: i, signInMethod: r } = t, s = Pe(t, ["providerId", "signInMethod"]);
+    if (!i || !r)
+      return null;
+    const o = new U(i, r);
+    return o.idToken = s.idToken || void 0, o.accessToken = s.accessToken || void 0, o.secret = s.secret, o.nonce = s.nonce, o.pendingToken = s.pendingToken || null, o;
+  }
+  /** @internal */
+  _getIdTokenResponse(e) {
+    const t = this.buildRequest();
+    return W(e, t);
+  }
+  /** @internal */
+  _linkToIdToken(e, t) {
+    const i = this.buildRequest();
+    return i.idToken = t, W(e, i);
+  }
+  /** @internal */
+  _getReauthenticationResolver(e) {
+    const t = this.buildRequest();
+    return t.autoCreate = !1, W(e, t);
+  }
+  buildRequest() {
+    const e = {
+      requestUri: ai,
+      returnSecureToken: !0
+    };
+    if (this.pendingToken)
+      e.pendingToken = this.pendingToken;
+    else {
+      const t = {};
+      this.idToken && (t.id_token = this.idToken), this.accessToken && (t.access_token = this.accessToken), this.secret && (t.oauth_token_secret = this.secret), t.providerId = this.providerId, this.nonce && !this.pendingToken && (t.nonce = this.nonce), e.postBody = K(t);
+    }
+    return e;
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Dt {
+  /**
+   * Constructor for generic OAuth providers.
+   *
+   * @param providerId - Provider for which credentials should be generated.
+   */
+  constructor(e) {
+    this.providerId = e, this.defaultLanguageCode = null, this.customParameters = {};
+  }
+  /**
+   * Set the language gode.
+   *
+   * @param languageCode - language code
+   */
+  setDefaultLanguage(e) {
+    this.defaultLanguageCode = e;
+  }
+  /**
+   * Sets the OAuth custom parameters to pass in an OAuth request for popup and redirect sign-in
+   * operations.
+   *
+   * @remarks
+   * For a detailed list, check the reserved required OAuth 2.0 parameters such as `client_id`,
+   * `redirect_uri`, `scope`, `response_type`, and `state` are not allowed and will be ignored.
+   *
+   * @param customOAuthParameters - The custom OAuth parameters to pass in the OAuth request.
+   */
+  setCustomParameters(e) {
+    return this.customParameters = e, this;
+  }
+  /**
+   * Retrieve the current list of {@link CustomParameters}.
+   */
+  getCustomParameters() {
+    return this.customParameters;
+  }
+}
+/**
+ * @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 Y extends Dt {
+  constructor() {
+    super(...arguments), this.scopes = [];
+  }
+  /**
+   * Add an OAuth scope to the credential.
+   *
+   * @param scope - Provider OAuth scope to add.
+   */
+  addScope(e) {
+    return this.scopes.includes(e) || this.scopes.push(e), this;
+  }
+  /**
+   * Retrieve the current list of OAuth scopes.
+   */
+  getScopes() {
+    return [...this.scopes];
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class A extends Y {
+  constructor() {
+    super(
+      "facebook.com"
+      /* ProviderId.FACEBOOK */
+    );
+  }
+  /**
+   * Creates a credential for Facebook.
+   *
+   * @example
+   * ```javascript
+   * // `event` from the Facebook auth.authResponseChange callback.
+   * const credential = FacebookAuthProvider.credential(event.authResponse.accessToken);
+   * const result = await signInWithCredential(credential);
+   * ```
+   *
+   * @param accessToken - Facebook access token.
+   */
+  static credential(e) {
+    return U._fromParams({
+      providerId: A.PROVIDER_ID,
+      signInMethod: A.FACEBOOK_SIGN_IN_METHOD,
+      accessToken: e
+    });
+  }
+  /**
+   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
+   *
+   * @param userCredential - The user credential.
+   */
+  static credentialFromResult(e) {
+    return A.credentialFromTaggedObject(e);
+  }
+  /**
+   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
+   * thrown during a sign-in, link, or reauthenticate operation.
+   *
+   * @param userCredential - The user credential.
+   */
+  static credentialFromError(e) {
+    return A.credentialFromTaggedObject(e.customData || {});
+  }
+  static credentialFromTaggedObject({ _tokenResponse: e }) {
+    if (!e || !("oauthAccessToken" in e) || !e.oauthAccessToken)
+      return null;
+    try {
+      return A.credential(e.oauthAccessToken);
+    } catch {
+      return null;
+    }
+  }
+}
+A.FACEBOOK_SIGN_IN_METHOD = "facebook.com";
+A.PROVIDER_ID = "facebook.com";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class C extends Y {
+  constructor() {
+    super(
+      "google.com"
+      /* ProviderId.GOOGLE */
+    ), this.addScope("profile");
+  }
+  /**
+   * Creates a credential for Google. At least one of ID token and access token is required.
+   *
+   * @example
+   * ```javascript
+   * // \`googleUser\` from the onsuccess Google Sign In callback.
+   * const credential = GoogleAuthProvider.credential(googleUser.getAuthResponse().id_token);
+   * const result = await signInWithCredential(credential);
+   * ```
+   *
+   * @param idToken - Google ID token.
+   * @param accessToken - Google access token.
+   */
+  static credential(e, t) {
+    return U._fromParams({
+      providerId: C.PROVIDER_ID,
+      signInMethod: C.GOOGLE_SIGN_IN_METHOD,
+      idToken: e,
+      accessToken: t
+    });
+  }
+  /**
+   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
+   *
+   * @param userCredential - The user credential.
+   */
+  static credentialFromResult(e) {
+    return C.credentialFromTaggedObject(e);
+  }
+  /**
+   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
+   * thrown during a sign-in, link, or reauthenticate operation.
+   *
+   * @param userCredential - The user credential.
+   */
+  static credentialFromError(e) {
+    return C.credentialFromTaggedObject(e.customData || {});
+  }
+  static credentialFromTaggedObject({ _tokenResponse: e }) {
+    if (!e)
+      return null;
+    const { oauthIdToken: t, oauthAccessToken: i } = e;
+    if (!t && !i)
+      return null;
+    try {
+      return C.credential(t, i);
+    } catch {
+      return null;
+    }
+  }
+}
+C.GOOGLE_SIGN_IN_METHOD = "google.com";
+C.PROVIDER_ID = "google.com";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class O extends Y {
+  constructor() {
+    super(
+      "github.com"
+      /* ProviderId.GITHUB */
+    );
+  }
+  /**
+   * Creates a credential for Github.
+   *
+   * @param accessToken - Github access token.
+   */
+  static credential(e) {
+    return U._fromParams({
+      providerId: O.PROVIDER_ID,
+      signInMethod: O.GITHUB_SIGN_IN_METHOD,
+      accessToken: e
+    });
+  }
+  /**
+   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
+   *
+   * @param userCredential - The user credential.
+   */
+  static credentialFromResult(e) {
+    return O.credentialFromTaggedObject(e);
+  }
+  /**
+   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
+   * thrown during a sign-in, link, or reauthenticate operation.
+   *
+   * @param userCredential - The user credential.
+   */
+  static credentialFromError(e) {
+    return O.credentialFromTaggedObject(e.customData || {});
+  }
+  static credentialFromTaggedObject({ _tokenResponse: e }) {
+    if (!e || !("oauthAccessToken" in e) || !e.oauthAccessToken)
+      return null;
+    try {
+      return O.credential(e.oauthAccessToken);
+    } catch {
+      return null;
+    }
+  }
+}
+O.GITHUB_SIGN_IN_METHOD = "github.com";
+O.PROVIDER_ID = "github.com";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class N extends Y {
+  constructor() {
+    super(
+      "twitter.com"
+      /* ProviderId.TWITTER */
+    );
+  }
+  /**
+   * Creates a credential for Twitter.
+   *
+   * @param token - Twitter access token.
+   * @param secret - Twitter secret.
+   */
+  static credential(e, t) {
+    return U._fromParams({
+      providerId: N.PROVIDER_ID,
+      signInMethod: N.TWITTER_SIGN_IN_METHOD,
+      oauthToken: e,
+      oauthTokenSecret: t
+    });
+  }
+  /**
+   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.
+   *
+   * @param userCredential - The user credential.
+   */
+  static credentialFromResult(e) {
+    return N.credentialFromTaggedObject(e);
+  }
+  /**
+   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was
+   * thrown during a sign-in, link, or reauthenticate operation.
+   *
+   * @param userCredential - The user credential.
+   */
+  static credentialFromError(e) {
+    return N.credentialFromTaggedObject(e.customData || {});
+  }
+  static credentialFromTaggedObject({ _tokenResponse: e }) {
+    if (!e)
+      return null;
+    const { oauthAccessToken: t, oauthTokenSecret: i } = e;
+    if (!t || !i)
+      return null;
+    try {
+      return N.credential(t, i);
+    } catch {
+      return null;
+    }
+  }
+}
+N.TWITTER_SIGN_IN_METHOD = "twitter.com";
+N.PROVIDER_ID = "twitter.com";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class D {
+  constructor(e) {
+    this.user = e.user, this.providerId = e.providerId, this._tokenResponse = e._tokenResponse, this.operationType = e.operationType;
+  }
+  static async _fromIdTokenResponse(e, t, i, r = !1) {
+    const s = await E._fromIdTokenResponse(e, i, r), o = Ze(i);
+    return new D({
+      user: s,
+      providerId: o,
+      _tokenResponse: i,
+      operationType: t
+    });
+  }
+  static async _forOperation(e, t, i) {
+    await e._updateTokensIfNecessary(
+      i,
+      /* reload */
+      !0
+    );
+    const r = Ze(i);
+    return new D({
+      user: e,
+      providerId: r,
+      _tokenResponse: i,
+      operationType: t
+    });
+  }
+}
+function Ze(n) {
+  return n.providerId ? n.providerId : "phoneNumber" in n ? "phone" : null;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class le extends Re {
+  constructor(e, t, i, r) {
+    var s;
+    super(t.code, t.message), this.operationType = i, this.user = r, Object.setPrototypeOf(this, le.prototype), this.customData = {
+      appName: e.name,
+      tenantId: (s = e.tenantId) !== null && s !== void 0 ? s : void 0,
+      _serverResponse: t.customData._serverResponse,
+      operationType: i
+    };
+  }
+  static _fromErrorAndOperation(e, t, i, r) {
+    return new le(e, t, i, r);
+  }
+}
+function Ft(n, e, t, i) {
+  return (e === "reauthenticate" ? t._getReauthenticationResolver(n) : t._getIdTokenResponse(n)).catch((s) => {
+    throw s.code === "auth/multi-factor-auth-required" ? le._fromErrorAndOperation(n, s, e, i) : s;
+  });
+}
+async function ci(n, e, t = !1) {
+  const i = await q(n, e._linkToIdToken(n.auth, await n.getIdToken()), t);
+  return D._forOperation(n, "link", i);
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function li(n, e, t = !1) {
+  const { auth: i } = n;
+  if (w(i.app))
+    return Promise.reject(L(i));
+  const r = "reauthenticate";
+  try {
+    const s = await q(n, Ft(i, r, e, n), t);
+    u(
+      s.idToken,
+      i,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    );
+    const o = Oe(s.idToken);
+    u(
+      o,
+      i,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    );
+    const { sub: c } = o;
+    return u(
+      n.uid === c,
+      i,
+      "user-mismatch"
+      /* AuthErrorCode.USER_MISMATCH */
+    ), D._forOperation(n, r, s);
+  } catch (s) {
+    throw (s == null ? void 0 : s.code) === "auth/user-not-found" && S(
+      i,
+      "user-mismatch"
+      /* AuthErrorCode.USER_MISMATCH */
+    ), s;
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function ui(n, e, t = !1) {
+  if (w(n.app))
+    return Promise.reject(L(n));
+  const i = "signIn", r = await Ft(n, i, e), s = await D._fromIdTokenResponse(n, i, r);
+  return t || await n._updateCurrentUser(s.user), s;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function di(n, e) {
+  return wt(n, "POST", "/v1/accounts:signInWithCustomToken", he(n, e));
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function hi(n, e) {
+  if (w(n.app))
+    return Promise.reject(L(n));
+  const t = pe(n), i = await di(t, {
+    token: e,
+    returnSecureToken: !0
+  }), r = await D._fromIdTokenResponse(t, "signIn", i);
+  return await t._updateCurrentUser(r.user), r;
+}
+function fi(n, e, t, i) {
+  return j(n).onIdTokenChanged(e, t, i);
+}
+function pi(n, e, t) {
+  return j(n).beforeAuthStateChanged(e, t);
+}
+const ue = "__sak";
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class xt {
+  constructor(e, t) {
+    this.storageRetriever = e, this.type = t;
+  }
+  _isAvailable() {
+    try {
+      return this.storage ? (this.storage.setItem(ue, "1"), this.storage.removeItem(ue), Promise.resolve(!0)) : Promise.resolve(!1);
+    } catch {
+      return Promise.resolve(!1);
+    }
+  }
+  _set(e, t) {
+    return this.storage.setItem(e, JSON.stringify(t)), Promise.resolve();
+  }
+  _get(e) {
+    const t = this.storage.getItem(e);
+    return Promise.resolve(t ? JSON.parse(t) : null);
+  }
+  _remove(e) {
+    return this.storage.removeItem(e), Promise.resolve();
+  }
+  get storage() {
+    return this.storageRetriever();
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function mi() {
+  const n = m();
+  return Ne(n) || fe(n);
+}
+const gi = 1e3, _i = 10;
+class Vt extends xt {
+  constructor() {
+    super(
+      () => window.localStorage,
+      "LOCAL"
+      /* PersistenceType.LOCAL */
+    ), this.boundEventHandler = (e, t) => this.onStorageEvent(e, t), this.listeners = {}, this.localCache = {}, this.pollTimer = null, this.safariLocalStorageNotSynced = mi() && qn(), this.fallbackToPolling = Nt(), this._shouldAllowMigration = !0;
+  }
+  forAllChangedKeys(e) {
+    for (const t of Object.keys(this.listeners)) {
+      const i = this.storage.getItem(t), r = this.localCache[t];
+      i !== r && e(t, r, i);
+    }
+  }
+  onStorageEvent(e, t = !1) {
+    if (!e.key) {
+      this.forAllChangedKeys((o, c, a) => {
+        this.notifyListeners(o, a);
+      });
+      return;
+    }
+    const i = e.key;
+    if (t ? this.detachListener() : this.stopPolling(), this.safariLocalStorageNotSynced) {
+      const o = this.storage.getItem(i);
+      if (e.newValue !== o)
+        e.newValue !== null ? this.storage.setItem(i, e.newValue) : this.storage.removeItem(i);
+      else if (this.localCache[i] === e.newValue && !t)
+        return;
+    }
+    const r = () => {
+      const o = this.storage.getItem(i);
+      !t && this.localCache[i] === o || this.notifyListeners(i, o);
+    }, s = this.storage.getItem(i);
+    Bn() && s !== e.newValue && e.newValue !== e.oldValue ? setTimeout(r, _i) : r();
+  }
+  notifyListeners(e, t) {
+    this.localCache[e] = t;
+    const i = this.listeners[e];
+    if (i)
+      for (const r of Array.from(i))
+        r(t && JSON.parse(t));
+  }
+  startPolling() {
+    this.stopPolling(), this.pollTimer = setInterval(() => {
+      this.forAllChangedKeys((e, t, i) => {
+        this.onStorageEvent(
+          new StorageEvent("storage", {
+            key: e,
+            oldValue: t,
+            newValue: i
+          }),
+          /* poll */
+          !0
+        );
+      });
+    }, gi);
+  }
+  stopPolling() {
+    this.pollTimer && (clearInterval(this.pollTimer), this.pollTimer = null);
+  }
+  attachListener() {
+    window.addEventListener("storage", this.boundEventHandler);
+  }
+  detachListener() {
+    window.removeEventListener("storage", this.boundEventHandler);
+  }
+  _addListener(e, t) {
+    Object.keys(this.listeners).length === 0 && (this.fallbackToPolling ? this.startPolling() : this.attachListener()), this.listeners[e] || (this.listeners[e] = /* @__PURE__ */ new Set(), this.localCache[e] = this.storage.getItem(e)), this.listeners[e].add(t);
+  }
+  _removeListener(e, t) {
+    this.listeners[e] && (this.listeners[e].delete(t), this.listeners[e].size === 0 && delete this.listeners[e]), Object.keys(this.listeners).length === 0 && (this.detachListener(), this.stopPolling());
+  }
+  // Update local cache on base operations:
+  async _set(e, t) {
+    await super._set(e, t), this.localCache[e] = JSON.stringify(t);
+  }
+  async _get(e) {
+    const t = await super._get(e);
+    return this.localCache[e] = JSON.stringify(t), t;
+  }
+  async _remove(e) {
+    await super._remove(e), delete this.localCache[e];
+  }
+}
+Vt.type = "LOCAL";
+const vi = Vt;
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Ht extends xt {
+  constructor() {
+    super(
+      () => window.sessionStorage,
+      "SESSION"
+      /* PersistenceType.SESSION */
+    );
+  }
+  _addListener(e, t) {
+  }
+  _removeListener(e, t) {
+  }
+}
+Ht.type = "SESSION";
+const $t = Ht;
+/**
+ * @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 Ii(n) {
+  return Promise.all(n.map(async (e) => {
+    try {
+      return {
+        fulfilled: !0,
+        value: await e
+      };
+    } catch (t) {
+      return {
+        fulfilled: !1,
+        reason: t
+      };
+    }
+  }));
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class me {
+  constructor(e) {
+    this.eventTarget = e, this.handlersMap = {}, this.boundEventHandler = this.handleEvent.bind(this);
+  }
+  /**
+   * Obtain an instance of a Receiver for a given event target, if none exists it will be created.
+   *
+   * @param eventTarget - An event target (such as window or self) through which the underlying
+   * messages will be received.
+   */
+  static _getInstance(e) {
+    const t = this.receivers.find((r) => r.isListeningto(e));
+    if (t)
+      return t;
+    const i = new me(e);
+    return this.receivers.push(i), i;
+  }
+  isListeningto(e) {
+    return this.eventTarget === e;
+  }
+  /**
+   * Fans out a MessageEvent to the appropriate listeners.
+   *
+   * @remarks
+   * Sends an {@link Status.ACK} upon receipt and a {@link Status.DONE} once all handlers have
+   * finished processing.
+   *
+   * @param event - The MessageEvent.
+   *
+   */
+  async handleEvent(e) {
+    const t = e, { eventId: i, eventType: r, data: s } = t.data, o = this.handlersMap[r];
+    if (!(o != null && o.size))
+      return;
+    t.ports[0].postMessage({
+      status: "ack",
+      eventId: i,
+      eventType: r
+    });
+    const c = Array.from(o).map(async (l) => l(t.origin, s)), a = await Ii(c);
+    t.ports[0].postMessage({
+      status: "done",
+      eventId: i,
+      eventType: r,
+      response: a
+    });
+  }
+  /**
+   * Subscribe an event handler for a particular event.
+   *
+   * @param eventType - Event name to subscribe to.
+   * @param eventHandler - The event handler which should receive the events.
+   *
+   */
+  _subscribe(e, t) {
+    Object.keys(this.handlersMap).length === 0 && this.eventTarget.addEventListener("message", this.boundEventHandler), this.handlersMap[e] || (this.handlersMap[e] = /* @__PURE__ */ new Set()), this.handlersMap[e].add(t);
+  }
+  /**
+   * Unsubscribe an event handler from a particular event.
+   *
+   * @param eventType - Event name to unsubscribe from.
+   * @param eventHandler - Optinoal event handler, if none provided, unsubscribe all handlers on this event.
+   *
+   */
+  _unsubscribe(e, t) {
+    this.handlersMap[e] && t && this.handlersMap[e].delete(t), (!t || this.handlersMap[e].size === 0) && delete this.handlersMap[e], Object.keys(this.handlersMap).length === 0 && this.eventTarget.removeEventListener("message", this.boundEventHandler);
+  }
+}
+me.receivers = [];
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function Me(n = "", e = 10) {
+  let t = "";
+  for (let i = 0; i < e; i++)
+    t += Math.floor(Math.random() * 10);
+  return n + t;
+}
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Ti {
+  constructor(e) {
+    this.target = e, this.handlers = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Unsubscribe the handler and remove it from our tracking Set.
+   *
+   * @param handler - The handler to unsubscribe.
+   */
+  removeMessageHandler(e) {
+    e.messageChannel && (e.messageChannel.port1.removeEventListener("message", e.onMessage), e.messageChannel.port1.close()), this.handlers.delete(e);
+  }
+  /**
+   * Send a message to the Receiver located at {@link target}.
+   *
+   * @remarks
+   * We'll first wait a bit for an ACK , if we get one we will wait significantly longer until the
+   * receiver has had a chance to fully process the event.
+   *
+   * @param eventType - Type of event to send.
+   * @param data - The payload of the event.
+   * @param timeout - Timeout for waiting on an ACK from the receiver.
+   *
+   * @returns An array of settled promises from all the handlers that were listening on the receiver.
+   */
+  async _send(e, t, i = 50) {
+    const r = typeof MessageChannel < "u" ? new MessageChannel() : null;
+    if (!r)
+      throw new Error(
+        "connection_unavailable"
+        /* _MessageError.CONNECTION_UNAVAILABLE */
+      );
+    let s, o;
+    return new Promise((c, a) => {
+      const l = Me("", 20);
+      r.port1.start();
+      const d = setTimeout(() => {
+        a(new Error(
+          "unsupported_event"
+          /* _MessageError.UNSUPPORTED_EVENT */
+        ));
+      }, i);
+      o = {
+        messageChannel: r,
+        onMessage(h) {
+          const g = h;
+          if (g.data.eventId === l)
+            switch (g.data.status) {
+              case "ack":
+                clearTimeout(d), s = setTimeout(
+                  () => {
+                    a(new Error(
+                      "timeout"
+                      /* _MessageError.TIMEOUT */
+                    ));
+                  },
+                  3e3
+                  /* _TimeoutDuration.COMPLETION */
+                );
+                break;
+              case "done":
+                clearTimeout(s), c(g.data.response);
+                break;
+              default:
+                clearTimeout(d), clearTimeout(s), a(new Error(
+                  "invalid_response"
+                  /* _MessageError.INVALID_RESPONSE */
+                ));
+                break;
+            }
+        }
+      }, this.handlers.add(o), r.port1.addEventListener("message", o.onMessage), this.target.postMessage({
+        eventType: e,
+        eventId: l,
+        data: t
+      }, [r.port2]);
+    }).finally(() => {
+      o && this.removeMessageHandler(o);
+    });
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function T() {
+  return window;
+}
+function wi(n) {
+  T().location.href = n;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function Wt() {
+  return typeof T().WorkerGlobalScope < "u" && typeof T().importScripts == "function";
+}
+async function yi() {
+  if (!(navigator != null && navigator.serviceWorker))
+    return null;
+  try {
+    return (await navigator.serviceWorker.ready).active;
+  } catch {
+    return null;
+  }
+}
+function Ei() {
+  var n;
+  return ((n = navigator == null ? void 0 : navigator.serviceWorker) === null || n === void 0 ? void 0 : n.controller) || null;
+}
+function ki() {
+  return Wt() ? self : null;
+}
+/**
+ * @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 jt = "firebaseLocalStorageDb", Si = 1, de = "firebaseLocalStorage", Gt = "fbase_key";
+class X {
+  constructor(e) {
+    this.request = e;
+  }
+  toPromise() {
+    return new Promise((e, t) => {
+      this.request.addEventListener("success", () => {
+        e(this.request.result);
+      }), this.request.addEventListener("error", () => {
+        t(this.request.error);
+      });
+    });
+  }
+}
+function ge(n, e) {
+  return n.transaction([de], e ? "readwrite" : "readonly").objectStore(de);
+}
+function bi() {
+  const n = indexedDB.deleteDatabase(jt);
+  return new X(n).toPromise();
+}
+function Se() {
+  const n = indexedDB.open(jt, Si);
+  return new Promise((e, t) => {
+    n.addEventListener("error", () => {
+      t(n.error);
+    }), n.addEventListener("upgradeneeded", () => {
+      const i = n.result;
+      try {
+        i.createObjectStore(de, { keyPath: Gt });
+      } catch (r) {
+        t(r);
+      }
+    }), n.addEventListener("success", async () => {
+      const i = n.result;
+      i.objectStoreNames.contains(de) ? e(i) : (i.close(), await bi(), e(await Se()));
+    });
+  });
+}
+async function et(n, e, t) {
+  const i = ge(n, !0).put({
+    [Gt]: e,
+    value: t
+  });
+  return new X(i).toPromise();
+}
+async function Ri(n, e) {
+  const t = ge(n, !1).get(e), i = await new X(t).toPromise();
+  return i === void 0 ? null : i.value;
+}
+function tt(n, e) {
+  const t = ge(n, !0).delete(e);
+  return new X(t).toPromise();
+}
+const Pi = 800, Ai = 3;
+class Bt {
+  constructor() {
+    this.type = "LOCAL", this._shouldAllowMigration = !0, this.listeners = {}, this.localCache = {}, this.pollTimer = null, this.pendingWrites = 0, this.receiver = null, this.sender = null, this.serviceWorkerReceiverAvailable = !1, this.activeServiceWorker = null, this._workerInitializationPromise = this.initializeServiceWorkerMessaging().then(() => {
+    }, () => {
+    });
+  }
+  async _openDb() {
+    return this.db ? this.db : (this.db = await Se(), this.db);
+  }
+  async _withRetries(e) {
+    let t = 0;
+    for (; ; )
+      try {
+        const i = await this._openDb();
+        return await e(i);
+      } catch (i) {
+        if (t++ > Ai)
+          throw i;
+        this.db && (this.db.close(), this.db = void 0);
+      }
+  }
+  /**
+   * IndexedDB events do not propagate from the main window to the worker context.  We rely on a
+   * postMessage interface to send these events to the worker ourselves.
+   */
+  async initializeServiceWorkerMessaging() {
+    return Wt() ? this.initializeReceiver() : this.initializeSender();
+  }
+  /**
+   * As the worker we should listen to events from the main window.
+   */
+  async initializeReceiver() {
+    this.receiver = me._getInstance(ki()), this.receiver._subscribe("keyChanged", async (e, t) => ({
+      keyProcessed: (await this._poll()).includes(t.key)
+    })), this.receiver._subscribe("ping", async (e, t) => [
+      "keyChanged"
+      /* _EventType.KEY_CHANGED */
+    ]);
+  }
+  /**
+   * As the main window, we should let the worker know when keys change (set and remove).
+   *
+   * @remarks
+   * {@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/ready | ServiceWorkerContainer.ready}
+   * may not resolve.
+   */
+  async initializeSender() {
+    var e, t;
+    if (this.activeServiceWorker = await yi(), !this.activeServiceWorker)
+      return;
+    this.sender = new Ti(this.activeServiceWorker);
+    const i = await this.sender._send(
+      "ping",
+      {},
+      800
+      /* _TimeoutDuration.LONG_ACK */
+    );
+    i && !((e = i[0]) === null || e === void 0) && e.fulfilled && !((t = i[0]) === null || t === void 0) && t.value.includes(
+      "keyChanged"
+      /* _EventType.KEY_CHANGED */
+    ) && (this.serviceWorkerReceiverAvailable = !0);
+  }
+  /**
+   * Let the worker know about a changed key, the exact key doesn't technically matter since the
+   * worker will just trigger a full sync anyway.
+   *
+   * @remarks
+   * For now, we only support one service worker per page.
+   *
+   * @param key - Storage key which changed.
+   */
+  async notifyServiceWorker(e) {
+    if (!(!this.sender || !this.activeServiceWorker || Ei() !== this.activeServiceWorker))
+      try {
+        await this.sender._send(
+          "keyChanged",
+          { key: e },
+          // Use long timeout if receiver has previously responded to a ping from us.
+          this.serviceWorkerReceiverAvailable ? 800 : 50
+          /* _TimeoutDuration.ACK */
+        );
+      } catch {
+      }
+  }
+  async _isAvailable() {
+    try {
+      if (!indexedDB)
+        return !1;
+      const e = await Se();
+      return await et(e, ue, "1"), await tt(e, ue), !0;
+    } catch {
+    }
+    return !1;
+  }
+  async _withPendingWrite(e) {
+    this.pendingWrites++;
+    try {
+      await e();
+    } finally {
+      this.pendingWrites--;
+    }
+  }
+  async _set(e, t) {
+    return this._withPendingWrite(async () => (await this._withRetries((i) => et(i, e, t)), this.localCache[e] = t, this.notifyServiceWorker(e)));
+  }
+  async _get(e) {
+    const t = await this._withRetries((i) => Ri(i, e));
+    return this.localCache[e] = t, t;
+  }
+  async _remove(e) {
+    return this._withPendingWrite(async () => (await this._withRetries((t) => tt(t, e)), delete this.localCache[e], this.notifyServiceWorker(e)));
+  }
+  async _poll() {
+    const e = await this._withRetries((r) => {
+      const s = ge(r, !1).getAll();
+      return new X(s).toPromise();
+    });
+    if (!e)
+      return [];
+    if (this.pendingWrites !== 0)
+      return [];
+    const t = [], i = /* @__PURE__ */ new Set();
+    if (e.length !== 0)
+      for (const { fbase_key: r, value: s } of e)
+        i.add(r), JSON.stringify(this.localCache[r]) !== JSON.stringify(s) && (this.notifyListeners(r, s), t.push(r));
+    for (const r of Object.keys(this.localCache))
+      this.localCache[r] && !i.has(r) && (this.notifyListeners(r, null), t.push(r));
+    return t;
+  }
+  notifyListeners(e, t) {
+    this.localCache[e] = t;
+    const i = this.listeners[e];
+    if (i)
+      for (const r of Array.from(i))
+        r(t);
+  }
+  startPolling() {
+    this.stopPolling(), this.pollTimer = setInterval(async () => this._poll(), Pi);
+  }
+  stopPolling() {
+    this.pollTimer && (clearInterval(this.pollTimer), this.pollTimer = null);
+  }
+  _addListener(e, t) {
+    Object.keys(this.listeners).length === 0 && this.startPolling(), this.listeners[e] || (this.listeners[e] = /* @__PURE__ */ new Set(), this._get(e)), this.listeners[e].add(t);
+  }
+  _removeListener(e, t) {
+    this.listeners[e] && (this.listeners[e].delete(t), this.listeners[e].size === 0 && delete this.listeners[e]), Object.keys(this.listeners).length === 0 && this.stopPolling();
+  }
+}
+Bt.type = "LOCAL";
+const Ci = Bt;
+new J(3e4, 6e4);
+/**
+ * @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 Oi(n, e) {
+  return e ? k(e) : (u(
+    n._popupRedirectResolver,
+    n,
+    "argument-error"
+    /* AuthErrorCode.ARGUMENT_ERROR */
+  ), n._popupRedirectResolver);
+}
+/**
+ * @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 Ue extends Ut {
+  constructor(e) {
+    super(
+      "custom",
+      "custom"
+      /* ProviderId.CUSTOM */
+    ), this.params = e;
+  }
+  _getIdTokenResponse(e) {
+    return W(e, this._buildIdpRequest());
+  }
+  _linkToIdToken(e, t) {
+    return W(e, this._buildIdpRequest(t));
+  }
+  _getReauthenticationResolver(e) {
+    return W(e, this._buildIdpRequest());
+  }
+  _buildIdpRequest(e) {
+    const t = {
+      requestUri: this.params.requestUri,
+      sessionId: this.params.sessionId,
+      postBody: this.params.postBody,
+      tenantId: this.params.tenantId,
+      pendingToken: this.params.pendingToken,
+      returnSecureToken: !0,
+      returnIdpCredential: !0
+    };
+    return e && (t.idToken = e), t;
+  }
+}
+function Ni(n) {
+  return ui(n.auth, new Ue(n), n.bypassAuthState);
+}
+function Li(n) {
+  const { auth: e, user: t } = n;
+  return u(
+    t,
+    e,
+    "internal-error"
+    /* AuthErrorCode.INTERNAL_ERROR */
+  ), li(t, new Ue(n), n.bypassAuthState);
+}
+async function Mi(n) {
+  const { auth: e, user: t } = n;
+  return u(
+    t,
+    e,
+    "internal-error"
+    /* AuthErrorCode.INTERNAL_ERROR */
+  ), ci(t, new Ue(n), n.bypassAuthState);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class qt {
+  constructor(e, t, i, r, s = !1) {
+    this.auth = e, this.resolver = i, this.user = r, this.bypassAuthState = s, this.pendingPromise = null, this.eventManager = null, this.filter = Array.isArray(t) ? t : [t];
+  }
+  execute() {
+    return new Promise(async (e, t) => {
+      this.pendingPromise = { resolve: e, reject: t };
+      try {
+        this.eventManager = await this.resolver._initialize(this.auth), await this.onExecution(), this.eventManager.registerConsumer(this);
+      } catch (i) {
+        this.reject(i);
+      }
+    });
+  }
+  async onAuthEvent(e) {
+    const { urlResponse: t, sessionId: i, postBody: r, tenantId: s, error: o, type: c } = e;
+    if (o) {
+      this.reject(o);
+      return;
+    }
+    const a = {
+      auth: this.auth,
+      requestUri: t,
+      sessionId: i,
+      tenantId: s || void 0,
+      postBody: r || void 0,
+      user: this.user,
+      bypassAuthState: this.bypassAuthState
+    };
+    try {
+      this.resolve(await this.getIdpTask(c)(a));
+    } catch (l) {
+      this.reject(l);
+    }
+  }
+  onError(e) {
+    this.reject(e);
+  }
+  getIdpTask(e) {
+    switch (e) {
+      case "signInViaPopup":
+      case "signInViaRedirect":
+        return Ni;
+      case "linkViaPopup":
+      case "linkViaRedirect":
+        return Mi;
+      case "reauthViaPopup":
+      case "reauthViaRedirect":
+        return Li;
+      default:
+        S(
+          this.auth,
+          "internal-error"
+          /* AuthErrorCode.INTERNAL_ERROR */
+        );
+    }
+  }
+  resolve(e) {
+    b(this.pendingPromise, "Pending promise was never set"), this.pendingPromise.resolve(e), this.unregisterAndCleanUp();
+  }
+  reject(e) {
+    b(this.pendingPromise, "Pending promise was never set"), this.pendingPromise.reject(e), this.unregisterAndCleanUp();
+  }
+  unregisterAndCleanUp() {
+    this.eventManager && this.eventManager.unregisterConsumer(this), this.pendingPromise = null, this.cleanUp();
+  }
+}
+/**
+ * @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 Ui = new J(2e3, 1e4);
+class V extends qt {
+  constructor(e, t, i, r, s) {
+    super(e, t, r, s), this.provider = i, this.authWindow = null, this.pollId = null, V.currentPopupAction && V.currentPopupAction.cancel(), V.currentPopupAction = this;
+  }
+  async executeNotNull() {
+    const e = await this.execute();
+    return u(
+      e,
+      this.auth,
+      "internal-error"
+      /* AuthErrorCode.INTERNAL_ERROR */
+    ), e;
+  }
+  async onExecution() {
+    b(this.filter.length === 1, "Popup operations only handle one event");
+    const e = Me();
+    this.authWindow = await this.resolver._openPopup(
+      this.auth,
+      this.provider,
+      this.filter[0],
+      // There's always one, see constructor
+      e
+    ), this.authWindow.associatedEvent = e, this.resolver._originValidation(this.auth).catch((t) => {
+      this.reject(t);
+    }), this.resolver._isIframeWebStorageSupported(this.auth, (t) => {
+      t || this.reject(I(
+        this.auth,
+        "web-storage-unsupported"
+        /* AuthErrorCode.WEB_STORAGE_UNSUPPORTED */
+      ));
+    }), this.pollUserCancellation();
+  }
+  get eventId() {
+    var e;
+    return ((e = this.authWindow) === null || e === void 0 ? void 0 : e.associatedEvent) || null;
+  }
+  cancel() {
+    this.reject(I(
+      this.auth,
+      "cancelled-popup-request"
+      /* AuthErrorCode.EXPIRED_POPUP_REQUEST */
+    ));
+  }
+  cleanUp() {
+    this.authWindow && this.authWindow.close(), this.pollId && window.clearTimeout(this.pollId), this.authWindow = null, this.pollId = null, V.currentPopupAction = null;
+  }
+  pollUserCancellation() {
+    const e = () => {
+      var t, i;
+      if (!((i = (t = this.authWindow) === null || t === void 0 ? void 0 : t.window) === null || i === void 0) && i.closed) {
+        this.pollId = window.setTimeout(
+          () => {
+            this.pollId = null, this.reject(I(
+              this.auth,
+              "popup-closed-by-user"
+              /* AuthErrorCode.POPUP_CLOSED_BY_USER */
+            ));
+          },
+          8e3
+          /* _Timeout.AUTH_EVENT */
+        );
+        return;
+      }
+      this.pollId = window.setTimeout(e, Ui.get());
+    };
+    e();
+  }
+}
+V.currentPopupAction = null;
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const Di = "pendingRedirect", se = /* @__PURE__ */ new Map();
+class Fi extends qt {
+  constructor(e, t, i = !1) {
+    super(e, [
+      "signInViaRedirect",
+      "linkViaRedirect",
+      "reauthViaRedirect",
+      "unknown"
+      /* AuthEventType.UNKNOWN */
+    ], t, void 0, i), this.eventId = null;
+  }
+  /**
+   * Override the execute function; if we already have a redirect result, then
+   * just return it.
+   */
+  async execute() {
+    let e = se.get(this.auth._key());
+    if (!e) {
+      try {
+        const i = await xi(this.resolver, this.auth) ? await super.execute() : null;
+        e = () => Promise.resolve(i);
+      } catch (t) {
+        e = () => Promise.reject(t);
+      }
+      se.set(this.auth._key(), e);
+    }
+    return this.bypassAuthState || se.set(this.auth._key(), () => Promise.resolve(null)), e();
+  }
+  async onAuthEvent(e) {
+    if (e.type === "signInViaRedirect")
+      return super.onAuthEvent(e);
+    if (e.type === "unknown") {
+      this.resolve(null);
+      return;
+    }
+    if (e.eventId) {
+      const t = await this.auth._redirectUserForId(e.eventId);
+      if (t)
+        return this.user = t, super.onAuthEvent(e);
+      this.resolve(null);
+    }
+  }
+  async onExecution() {
+  }
+  cleanUp() {
+  }
+}
+async function xi(n, e) {
+  const t = $i(e), i = Hi(n);
+  if (!await i._isAvailable())
+    return !1;
+  const r = await i._get(t) === "true";
+  return await i._remove(t), r;
+}
+function Vi(n, e) {
+  se.set(n._key(), e);
+}
+function Hi(n) {
+  return k(n._redirectPersistence);
+}
+function $i(n) {
+  return re(Di, n.config.apiKey, n.name);
+}
+async function Wi(n, e, t = !1) {
+  if (w(n.app))
+    return Promise.reject(L(n));
+  const i = pe(n), r = Oi(i, e), o = await new Fi(i, r, t).execute();
+  return o && !t && (delete o.user._redirectEventId, await i._persistUserIfCurrent(o.user), await i._setRedirectUser(null, e)), o;
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const ji = 10 * 60 * 1e3;
+class Gi {
+  constructor(e) {
+    this.auth = e, this.cachedEventUids = /* @__PURE__ */ new Set(), this.consumers = /* @__PURE__ */ new Set(), this.queuedRedirectEvent = null, this.hasHandledPotentialRedirect = !1, this.lastProcessedEventTime = Date.now();
+  }
+  registerConsumer(e) {
+    this.consumers.add(e), this.queuedRedirectEvent && this.isEventForConsumer(this.queuedRedirectEvent, e) && (this.sendToConsumer(this.queuedRedirectEvent, e), this.saveEventToCache(this.queuedRedirectEvent), this.queuedRedirectEvent = null);
+  }
+  unregisterConsumer(e) {
+    this.consumers.delete(e);
+  }
+  onEvent(e) {
+    if (this.hasEventBeenHandled(e))
+      return !1;
+    let t = !1;
+    return this.consumers.forEach((i) => {
+      this.isEventForConsumer(e, i) && (t = !0, this.sendToConsumer(e, i), this.saveEventToCache(e));
+    }), this.hasHandledPotentialRedirect || !Bi(e) || (this.hasHandledPotentialRedirect = !0, t || (this.queuedRedirectEvent = e, t = !0)), t;
+  }
+  sendToConsumer(e, t) {
+    var i;
+    if (e.error && !zt(e)) {
+      const r = ((i = e.error.code) === null || i === void 0 ? void 0 : i.split("auth/")[1]) || "internal-error";
+      t.onError(I(this.auth, r));
+    } else
+      t.onAuthEvent(e);
+  }
+  isEventForConsumer(e, t) {
+    const i = t.eventId === null || !!e.eventId && e.eventId === t.eventId;
+    return t.filter.includes(e.type) && i;
+  }
+  hasEventBeenHandled(e) {
+    return Date.now() - this.lastProcessedEventTime >= ji && this.cachedEventUids.clear(), this.cachedEventUids.has(nt(e));
+  }
+  saveEventToCache(e) {
+    this.cachedEventUids.add(nt(e)), this.lastProcessedEventTime = Date.now();
+  }
+}
+function nt(n) {
+  return [n.type, n.eventId, n.sessionId, n.tenantId].filter((e) => e).join("-");
+}
+function zt({ type: n, error: e }) {
+  return n === "unknown" && (e == null ? void 0 : e.code) === "auth/no-auth-event";
+}
+function Bi(n) {
+  switch (n.type) {
+    case "signInViaRedirect":
+    case "linkViaRedirect":
+    case "reauthViaRedirect":
+      return !0;
+    case "unknown":
+      return zt(n);
+    default:
+      return !1;
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+async function qi(n, e = {}) {
+  return G(n, "GET", "/v1/projects", e);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const zi = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/, Ki = /^https?/;
+async function Ji(n) {
+  if (n.config.emulator)
+    return;
+  const { authorizedDomains: e } = await qi(n);
+  for (const t of e)
+    try {
+      if (Yi(t))
+        return;
+    } catch {
+    }
+  S(
+    n,
+    "unauthorized-domain"
+    /* AuthErrorCode.INVALID_ORIGIN */
+  );
+}
+function Yi(n) {
+  const e = Ee(), { protocol: t, hostname: i } = new URL(e);
+  if (n.startsWith("chrome-extension://")) {
+    const o = new URL(n);
+    return o.hostname === "" && i === "" ? t === "chrome-extension:" && n.replace("chrome-extension://", "") === e.replace("chrome-extension://", "") : t === "chrome-extension:" && o.hostname === i;
+  }
+  if (!Ki.test(t))
+    return !1;
+  if (zi.test(n))
+    return i === n;
+  const r = n.replace(/\./g, "\\.");
+  return new RegExp("^(.+\\." + r + "|" + r + ")$", "i").test(i);
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const Xi = new J(3e4, 6e4);
+function it() {
+  const n = T().___jsl;
+  if (n != null && n.H) {
+    for (const e of Object.keys(n.H))
+      if (n.H[e].r = n.H[e].r || [], n.H[e].L = n.H[e].L || [], n.H[e].r = [...n.H[e].L], n.CP)
+        for (let t = 0; t < n.CP.length; t++)
+          n.CP[t] = null;
+  }
+}
+function Qi(n) {
+  return new Promise((e, t) => {
+    var i, r, s;
+    function o() {
+      it(), gapi.load("gapi.iframes", {
+        callback: () => {
+          e(gapi.iframes.getContext());
+        },
+        ontimeout: () => {
+          it(), t(I(
+            n,
+            "network-request-failed"
+            /* AuthErrorCode.NETWORK_REQUEST_FAILED */
+          ));
+        },
+        timeout: Xi.get()
+      });
+    }
+    if (!((r = (i = T().gapi) === null || i === void 0 ? void 0 : i.iframes) === null || r === void 0) && r.Iframe)
+      e(gapi.iframes.getContext());
+    else if (!((s = T().gapi) === null || s === void 0) && s.load)
+      o();
+    else {
+      const c = ti("iframefcb");
+      return T()[c] = () => {
+        gapi.load ? o() : t(I(
+          n,
+          "network-request-failed"
+          /* AuthErrorCode.NETWORK_REQUEST_FAILED */
+        ));
+      }, Zn(`${ei()}?onload=${c}`).catch((a) => t(a));
+    }
+  }).catch((e) => {
+    throw oe = null, e;
+  });
+}
+let oe = null;
+function Zi(n) {
+  return oe = oe || Qi(n), oe;
+}
+/**
+ * @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 er = new J(5e3, 15e3), tr = "__/auth/iframe", nr = "emulator/auth/iframe", ir = {
+  style: {
+    position: "absolute",
+    top: "-100px",
+    width: "1px",
+    height: "1px"
+  },
+  "aria-hidden": "true",
+  tabindex: "-1"
+}, rr = /* @__PURE__ */ new Map([
+  ["identitytoolkit.googleapis.com", "p"],
+  ["staging-identitytoolkit.sandbox.googleapis.com", "s"],
+  ["test-identitytoolkit.sandbox.googleapis.com", "t"]
+  // test
+]);
+function sr(n) {
+  const e = n.config;
+  u(
+    e.authDomain,
+    n,
+    "auth-domain-config-required"
+    /* AuthErrorCode.MISSING_AUTH_DOMAIN */
+  );
+  const t = e.emulator ? Ce(e, nr) : `https://${n.config.authDomain}/${tr}`, i = {
+    apiKey: e.apiKey,
+    appName: n.name,
+    v: z
+  }, r = rr.get(n.config.apiHost);
+  r && (i.eid = r);
+  const s = n._getFrameworks();
+  return s.length && (i.fw = s.join(",")), `${t}?${K(i).slice(1)}`;
+}
+async function or(n) {
+  const e = await Zi(n), t = T().gapi;
+  return u(
+    t,
+    n,
+    "internal-error"
+    /* AuthErrorCode.INTERNAL_ERROR */
+  ), e.open({
+    where: document.body,
+    url: sr(n),
+    messageHandlersFilter: t.iframes.CROSS_ORIGIN_IFRAMES_FILTER,
+    attributes: ir,
+    dontclear: !0
+  }, (i) => new Promise(async (r, s) => {
+    await i.restyle({
+      // Prevent iframe from closing on mouse out.
+      setHideOnLeave: !1
+    });
+    const o = I(
+      n,
+      "network-request-failed"
+      /* AuthErrorCode.NETWORK_REQUEST_FAILED */
+    ), c = T().setTimeout(() => {
+      s(o);
+    }, er.get());
+    function a() {
+      T().clearTimeout(c), r(i);
+    }
+    i.ping(a).then(a, () => {
+      s(o);
+    });
+  }));
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const ar = {
+  location: "yes",
+  resizable: "yes",
+  statusbar: "yes",
+  toolbar: "no"
+}, cr = 500, lr = 600, ur = "_blank", dr = "http://localhost";
+class rt {
+  constructor(e) {
+    this.window = e, this.associatedEvent = null;
+  }
+  close() {
+    if (this.window)
+      try {
+        this.window.close();
+      } catch {
+      }
+  }
+}
+function hr(n, e, t, i = cr, r = lr) {
+  const s = Math.max((window.screen.availHeight - r) / 2, 0).toString(), o = Math.max((window.screen.availWidth - i) / 2, 0).toString();
+  let c = "";
+  const a = Object.assign(Object.assign({}, ar), {
+    width: i.toString(),
+    height: r.toString(),
+    top: s,
+    left: o
+  }), l = m().toLowerCase();
+  t && (c = Rt(l) ? ur : t), bt(l) && (e = e || dr, a.scrollbars = "yes");
+  const d = Object.entries(a).reduce((g, [F, M]) => `${g}${F}=${M},`, "");
+  if (Gn(l) && c !== "_self")
+    return fr(e || "", c), new rt(null);
+  const h = window.open(e || "", c, d);
+  u(
+    h,
+    n,
+    "popup-blocked"
+    /* AuthErrorCode.POPUP_BLOCKED */
+  );
+  try {
+    h.focus();
+  } catch {
+  }
+  return new rt(h);
+}
+function fr(n, e) {
+  const t = document.createElement("a");
+  t.href = n, t.target = e;
+  const i = document.createEvent("MouseEvent");
+  i.initMouseEvent("click", !0, !0, window, 1, 0, 0, 0, 0, !1, !1, !1, !1, 1, null), t.dispatchEvent(i);
+}
+/**
+ * @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 pr = "__/auth/handler", mr = "emulator/auth/handler", gr = encodeURIComponent("fac");
+async function st(n, e, t, i, r, s) {
+  u(
+    n.config.authDomain,
+    n,
+    "auth-domain-config-required"
+    /* AuthErrorCode.MISSING_AUTH_DOMAIN */
+  ), u(
+    n.config.apiKey,
+    n,
+    "invalid-api-key"
+    /* AuthErrorCode.INVALID_API_KEY */
+  );
+  const o = {
+    apiKey: n.config.apiKey,
+    appName: n.name,
+    authType: t,
+    redirectUrl: i,
+    v: z,
+    eventId: r
+  };
+  if (e instanceof Dt) {
+    e.setDefaultLanguage(n.languageCode), o.providerId = e.providerId || "", wn(e.getCustomParameters()) || (o.customParameters = JSON.stringify(e.getCustomParameters()));
+    for (const [d, h] of Object.entries({}))
+      o[d] = h;
+  }
+  if (e instanceof Y) {
+    const d = e.getScopes().filter((h) => h !== "");
+    d.length > 0 && (o.scopes = d.join(","));
+  }
+  n.tenantId && (o.tid = n.tenantId);
+  const c = o;
+  for (const d of Object.keys(c))
+    c[d] === void 0 && delete c[d];
+  const a = await n._getAppCheckToken(), l = a ? `#${gr}=${encodeURIComponent(a)}` : "";
+  return `${_r(n)}?${K(c).slice(1)}${l}`;
+}
+function _r({ config: n }) {
+  return n.emulator ? Ce(n, mr) : `https://${n.authDomain}/${pr}`;
+}
+/**
+ * @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 we = "webStorageSupport";
+class vr {
+  constructor() {
+    this.eventManagers = {}, this.iframes = {}, this.originValidationPromises = {}, this._redirectPersistence = $t, this._completeRedirectFn = Wi, this._overrideRedirectResult = Vi;
+  }
+  // Wrapping in async even though we don't await anywhere in order
+  // to make sure errors are raised as promise rejections
+  async _openPopup(e, t, i, r) {
+    var s;
+    b((s = this.eventManagers[e._key()]) === null || s === void 0 ? void 0 : s.manager, "_initialize() not called before _openPopup()");
+    const o = await st(e, t, i, Ee(), r);
+    return hr(e, o, Me());
+  }
+  async _openRedirect(e, t, i, r) {
+    await this._originValidation(e);
+    const s = await st(e, t, i, Ee(), r);
+    return wi(s), new Promise(() => {
+    });
+  }
+  _initialize(e) {
+    const t = e._key();
+    if (this.eventManagers[t]) {
+      const { manager: r, promise: s } = this.eventManagers[t];
+      return r ? Promise.resolve(r) : (b(s, "If manager is not set, promise should be"), s);
+    }
+    const i = this.initAndGetManager(e);
+    return this.eventManagers[t] = { promise: i }, i.catch(() => {
+      delete this.eventManagers[t];
+    }), i;
+  }
+  async initAndGetManager(e) {
+    const t = await or(e), i = new Gi(e);
+    return t.register("authEvent", (r) => (u(
+      r == null ? void 0 : r.authEvent,
+      e,
+      "invalid-auth-event"
+      /* AuthErrorCode.INVALID_AUTH_EVENT */
+    ), {
+      status: i.onEvent(r.authEvent) ? "ACK" : "ERROR"
+      /* GapiOutcome.ERROR */
+    }), gapi.iframes.CROSS_ORIGIN_IFRAMES_FILTER), this.eventManagers[e._key()] = { manager: i }, this.iframes[e._key()] = t, i;
+  }
+  _isIframeWebStorageSupported(e, t) {
+    this.iframes[e._key()].send(we, { type: we }, (r) => {
+      var s;
+      const o = (s = r == null ? void 0 : r[0]) === null || s === void 0 ? void 0 : s[we];
+      o !== void 0 && t(!!o), S(
+        e,
+        "internal-error"
+        /* AuthErrorCode.INTERNAL_ERROR */
+      );
+    }, gapi.iframes.CROSS_ORIGIN_IFRAMES_FILTER);
+  }
+  _originValidation(e) {
+    const t = e._key();
+    return this.originValidationPromises[t] || (this.originValidationPromises[t] = Ji(e)), this.originValidationPromises[t];
+  }
+  get _shouldInitProactively() {
+    return Nt() || Ne() || fe();
+  }
+}
+const Ir = vr;
+var ot = "@firebase/auth", at = "1.7.5";
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Tr {
+  constructor(e) {
+    this.auth = e, this.internalListeners = /* @__PURE__ */ new Map();
+  }
+  getUid() {
+    var e;
+    return this.assertAuthConfigured(), ((e = this.auth.currentUser) === null || e === void 0 ? void 0 : e.uid) || null;
+  }
+  async getToken(e) {
+    return this.assertAuthConfigured(), await this.auth._initializationPromise, this.auth.currentUser ? { accessToken: await this.auth.currentUser.getIdToken(e) } : null;
+  }
+  addAuthTokenListener(e) {
+    if (this.assertAuthConfigured(), this.internalListeners.has(e))
+      return;
+    const t = this.auth.onIdTokenChanged((i) => {
+      e((i == null ? void 0 : i.stsTokenManager.accessToken) || null);
+    });
+    this.internalListeners.set(e, t), this.updateProactiveRefresh();
+  }
+  removeAuthTokenListener(e) {
+    this.assertAuthConfigured();
+    const t = this.internalListeners.get(e);
+    t && (this.internalListeners.delete(e), t(), this.updateProactiveRefresh());
+  }
+  assertAuthConfigured() {
+    u(
+      this.auth._initializationPromise,
+      "dependent-sdk-initialized-before-auth"
+      /* AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH */
+    );
+  }
+  updateProactiveRefresh() {
+    this.internalListeners.size > 0 ? this.auth._startProactiveRefresh() : this.auth._stopProactiveRefresh();
+  }
+}
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function wr(n) {
+  switch (n) {
+    case "Node":
+      return "node";
+    case "ReactNative":
+      return "rn";
+    case "Worker":
+      return "webworker";
+    case "Cordova":
+      return "cordova";
+    case "WebExtension":
+      return "web-extension";
+    default:
+      return;
+  }
+}
+function yr(n) {
+  je(new Ge(
+    "auth",
+    (e, { options: t }) => {
+      const i = e.getProvider("app").getImmediate(), r = e.getProvider("heartbeat"), s = e.getProvider("app-check-internal"), { apiKey: o, authDomain: c } = i.options;
+      u(o && !o.includes(":"), "invalid-api-key", { appName: i.name });
+      const a = {
+        apiKey: o,
+        authDomain: c,
+        clientPlatform: n,
+        apiHost: "identitytoolkit.googleapis.com",
+        tokenApiHost: "securetoken.googleapis.com",
+        apiScheme: "https",
+        sdkClientVersion: Lt(n)
+      }, l = new Xn(i, r, s, a);
+      return ii(l, t), l;
+    },
+    "PUBLIC"
+    /* ComponentType.PUBLIC */
+  ).setInstantiationMode(
+    "EXPLICIT"
+    /* InstantiationMode.EXPLICIT */
+  ).setInstanceCreatedCallback((e, t, i) => {
+    e.getProvider(
+      "auth-internal"
+      /* _ComponentName.AUTH_INTERNAL */
+    ).initialize();
+  })), je(new Ge(
+    "auth-internal",
+    (e) => {
+      const t = pe(e.getProvider(
+        "auth"
+        /* _ComponentName.AUTH */
+      ).getImmediate());
+      return ((i) => new Tr(i))(t);
+    },
+    "PRIVATE"
+    /* ComponentType.PRIVATE */
+  ).setInstantiationMode(
+    "EXPLICIT"
+    /* InstantiationMode.EXPLICIT */
+  )), ye(ot, at, wr(n)), ye(ot, at, "esm2017");
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const Er = 5 * 60, kr = ft("authIdTokenMaxAge") || Er;
+let ct = null;
+const Sr = (n) => async (e) => {
+  const t = e && await e.getIdTokenResult(), i = t && ((/* @__PURE__ */ new Date()).getTime() - Date.parse(t.issuedAtTime)) / 1e3;
+  if (i && i > kr)
+    return;
+  const r = t == null ? void 0 : t.token;
+  ct !== r && (ct = r, await fetch(n, {
+    method: r ? "POST" : "DELETE",
+    headers: r ? {
+      Authorization: `Bearer ${r}`
+    } : {}
+  }));
+};
+function br(n = _n()) {
+  const e = pt(n, "auth");
+  if (e.isInitialized())
+    return e.getImmediate();
+  const t = ni(n, {
+    popupRedirectResolver: Ir,
+    persistence: [
+      Ci,
+      vi,
+      $t
+    ]
+  }), i = ft("authTokenSyncURL");
+  if (i && typeof isSecureContext == "boolean" && isSecureContext) {
+    const s = new URL(i, location.origin);
+    if (location.origin === s.origin) {
+      const o = Sr(s.toString());
+      pi(t, o, () => o(t.currentUser)), fi(t, (c) => o(c));
+    }
+  }
+  const r = gn("auth");
+  return r && ri(t, `http://${r}`), t;
+}
+function Rr() {
+  var n, e;
+  return (e = (n = document.getElementsByTagName("head")) === null || n === void 0 ? void 0 : n[0]) !== null && e !== void 0 ? e : document;
+}
+Qn({
+  loadJS(n) {
+    return new Promise((e, t) => {
+      const i = document.createElement("script");
+      i.setAttribute("src", n), i.onload = e, i.onerror = (r) => {
+        const s = I(
+          "internal-error"
+          /* AuthErrorCode.INTERNAL_ERROR */
+        );
+        s.customData = r, t(s);
+      }, i.type = "text/javascript", i.charset = "UTF-8", Rr().appendChild(i);
+    });
+  },
+  gapiScript: "https://apis.google.com/js/api.js",
+  recaptchaV2Script: "https://www.google.com/recaptcha/api.js",
+  recaptchaEnterpriseScript: "https://www.google.com/recaptcha/enterprise.js?render="
+});
+yr(
+  "Browser"
+  /* ClientPlatform.BROWSER */
+);
+var Pr = { firebase: { apiKey: "AIzaSyA_isPR1-9bX7UmRiJIhsIRNNwdn6DdmW4", authDomain: "feedme-253402.firebaseapp.com", databaseURL: "https://feedme-253402.firebaseio.com", projectId: "feedme-253402", storageBucket: "image.feedme.cc", messagingSenderId: "128512026847", appId: "1:128512026847:web:7c5c8ab7e8b90502dc616a", measurementId: "G-LTKS7N2HQS" }, assetBucketUrl: "static.feedme.cc", clientId: "d5f8840d63dbb758b6c4ee2a5e8b013d15dd25e242c457481326062b83962476" }, Ar = { authUrl: "https://portal-v2.feedmeapi.com/", slackWebhookUrl: "https://hooks.slack.com/services/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", appUrl: "member.feedme.cc", crmUrl: "crm.feedme.cc", paymentPortalUrl: "https://portal.feedme.cc/payment/payout-account", marketingV1Portal: "https://marketing-v1.feedme.cc" };
+const Cr = {
+  key: 1,
+  class: "h-full w-full"
+}, Or = ["src"], Gr = /* @__PURE__ */ lt({
+  __name: "App",
+  setup(n) {
+    const e = We(), t = on(), i = an(), r = cn(), s = ln(), o = ht(), c = te(o.query.showHeader !== "false"), a = te(!1), { currentBusiness: l } = We(), d = te(!1), h = Ve(() => i.version), g = Ve(() => {
+      const p = e.currentCountry.value || "MY", _ = Be.getIdToken(), v = l.value._id;
+      return `${Ar.marketingV1Portal}/b/${v}/marketing/overview?showHeader=false&country=${p}&token=${_}`;
+    });
+    async function F() {
+      if (yn().length) {
+        console.warn("CONNECT: initFirebase: Firebase already initialized");
+        return;
+      }
+      const p = En(Pr.firebase), _ = await sn.getCustomToken(), v = br();
+      await hi(v, _), kn(p), console.log("initFirebase", p);
+    }
+    const M = async () => {
+      d.value = !1, await tn(), console.log("forceRerender"), Be.setBusinessId(l.value._id), await i.readPremium(), !a.value && h.value === "v2" ? e.registerSidebarComponent(Sn) : e.hideSidebarToggle(!0), await F(), a.value = !0, d.value = !0;
+    };
+    return Xt(() => {
+      if (t.initProvider(r, s), !c.value) {
+        const p = document.getElementsByClassName("app-header")[0], _ = document.getElementsByClassName("app-sidebar")[0], v = document.getElementsByClassName("app-container")[0], x = document.getElementsByTagName("main")[0];
+        p == null || p.classList.add("!hidden"), _ == null || _.classList.add("!pt-0"), v == null || v.classList.add("!pt-0"), x == null || x.classList.add("!pt-0"), e.hideSidebarToggle(!0);
+      }
+      l.value != null && M();
+    }), ut(
+      () => e.currentBusiness.value,
+      async (p) => {
+        p != null && M();
+      }
+    ), (p, _) => (ne(), He(Qt, null, [
+      P(d) && P(h) === "v2" ? (ne(), dt(P(rn), { key: 0 })) : $e("", !0),
+      P(d) && P(h) !== "v2" ? (ne(), He("div", Cr, [
+        Zt(un, {
+          json: { url: P(g) }
+        }, null, 8, ["json"]),
+        en("iframe", {
+          allow: "clipboard-read; clipboard-write",
+          frameBorder: "0",
+          height: "100%",
+          width: "100%",
+          src: P(g)
+        }, null, 8, Or)
+      ])) : $e("", !0)
+    ], 64));
+  }
+});
+export {
+  Gr as default
+};