@ethora/chat-component 26.7.4 → 26.7.6

package/dist/index.esm-CRM4VCRa.js

@@ -0,0 +1,943 @@
+import { r as m, _ as y, C as T, a as R, E as Q, o as M, F as Se, g as I, b as Ae, v as Ee, i as _e, c as Oe, d as A } from "./index.esm2017-CL0mvq6y.js";
+const Z = "@firebase/installations", P = "0.6.17";
+const ee = 1e4, te = `w:${P}`, ne = "FIS_v2", Ce = "https://firebaseinstallations.googleapis.com/v1", Ne = 3600 * 1e3, De = "installations", Re = "Installations";
+const Me = {
+  "missing-app-config-values": 'Missing App configuration value: "{$valueName}"',
+  "not-registered": "Firebase Installation is not registered.",
+  "installation-not-found": "Firebase Installation not found.",
+  "request-failed": '{$requestName} request failed with error "{$serverCode} {$serverStatus}: {$serverMessage}"',
+  "app-offline": "Could not process request. Application offline.",
+  "delete-pending-registration": "Can't delete installation while there is a pending registration request."
+}, g = new Q(De, Re, Me);
+function oe(e) {
+  return e instanceof Se && e.code.includes(
+    "request-failed"
+    /* ErrorCode.REQUEST_FAILED */
+  );
+}
+function ie({ projectId: e }) {
+  return `${Ce}/projects/${e}/installations`;
+}
+function re(e) {
+  return {
+    token: e.token,
+    requestStatus: 2,
+    expiresIn: je(e.expiresIn),
+    creationTime: Date.now()
+  };
+}
+async function ae(e, t) {
+  const o = (await t.json()).error;
+  return g.create("request-failed", {
+    requestName: e,
+    serverCode: o.code,
+    serverMessage: o.message,
+    serverStatus: o.status
+  });
+}
+function se({ apiKey: e }) {
+  return new Headers({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-goog-api-key": e
+  });
+}
+function Pe(e, { refreshToken: t }) {
+  const n = se(e);
+  return n.append("Authorization", Fe(t)), n;
+}
+async function ce(e) {
+  const t = await e();
+  return t.status >= 500 && t.status < 600 ? e() : t;
+}
+function je(e) {
+  return Number(e.replace("s", "000"));
+}
+function Fe(e) {
+  return `${ne} ${e}`;
+}
+async function $e({ appConfig: e, heartbeatServiceProvider: t }, { fid: n }) {
+  const o = ie(e), i = se(e), r = t.getImmediate({
+    optional: !0
+  });
+  if (r) {
+    const d = await r.getHeartbeatsHeader();
+    d && i.append("x-firebase-client", d);
+  }
+  const a = {
+    fid: n,
+    authVersion: ne,
+    appId: e.appId,
+    sdkVersion: te
+  }, c = {
+    method: "POST",
+    headers: i,
+    body: JSON.stringify(a)
+  }, f = await ce(() => fetch(o, c));
+  if (f.ok) {
+    const d = await f.json();
+    return {
+      fid: d.fid || n,
+      registrationStatus: 2,
+      refreshToken: d.refreshToken,
+      authToken: re(d.authToken)
+    };
+  } else
+    throw await ae("Create Installation", f);
+}
+function ue(e) {
+  return new Promise((t) => {
+    setTimeout(t, e);
+  });
+}
+function Ke(e) {
+  return btoa(String.fromCharCode(...e)).replace(/\+/g, "-").replace(/\//g, "_");
+}
+const qe = /^[cdef][\w-]{21}$/, D = "";
+function Le() {
+  try {
+    const e = new Uint8Array(17);
+    (self.crypto || self.msCrypto).getRandomValues(e), e[0] = 112 + e[0] % 16;
+    const n = xe(e);
+    return qe.test(n) ? n : D;
+  } catch {
+    return D;
+  }
+}
+function xe(e) {
+  return Ke(e).substr(0, 22);
+}
+function v(e) {
+  return `${e.appName}!${e.appId}`;
+}
+const de = /* @__PURE__ */ new Map();
+function fe(e, t) {
+  const n = v(e);
+  pe(n, t), Ve(n, t);
+}
+function pe(e, t) {
+  const n = de.get(e);
+  if (n)
+    for (const o of n)
+      o(t);
+}
+function Ve(e, t) {
+  const n = Be();
+  n && n.postMessage({ key: e, fid: t }), He();
+}
+let l = null;
+function Be() {
+  return !l && "BroadcastChannel" in self && (l = new BroadcastChannel("[Firebase] FID Change"), l.onmessage = (e) => {
+    pe(e.data.key, e.data.fid);
+  }), l;
+}
+function He() {
+  de.size === 0 && l && (l.close(), l = null);
+}
+const We = "firebase-installations-database", Ue = 1, w = "firebase-installations-store";
+let E = null;
+function j() {
+  return E || (E = M(We, Ue, {
+    upgrade: (e, t) => {
+      t === 0 && e.createObjectStore(w);
+    }
+  })), E;
+}
+async function k(e, t) {
+  const n = v(e), i = (await j()).transaction(w, "readwrite"), r = i.objectStore(w), a = await r.get(n);
+  return await r.put(t, n), await i.done, (!a || a.fid !== t.fid) && fe(e, t.fid), t;
+}
+async function le(e) {
+  const t = v(e), o = (await j()).transaction(w, "readwrite");
+  await o.objectStore(w).delete(t), await o.done;
+}
+async function S(e, t) {
+  const n = v(e), i = (await j()).transaction(w, "readwrite"), r = i.objectStore(w), a = await r.get(n), c = t(a);
+  return c === void 0 ? await r.delete(n) : await r.put(c, n), await i.done, c && (!a || a.fid !== c.fid) && fe(e, c.fid), c;
+}
+async function F(e) {
+  let t;
+  const n = await S(e.appConfig, (o) => {
+    const i = Ge(o), r = Je(e, i);
+    return t = r.registrationPromise, r.installationEntry;
+  });
+  return n.fid === D ? { installationEntry: await t } : {
+    installationEntry: n,
+    registrationPromise: t
+  };
+}
+function Ge(e) {
+  const t = e || {
+    fid: Le(),
+    registrationStatus: 0
+    /* RequestStatus.NOT_STARTED */
+  };
+  return ge(t);
+}
+function Je(e, t) {
+  if (t.registrationStatus === 0) {
+    if (!navigator.onLine) {
+      const i = Promise.reject(g.create(
+        "app-offline"
+        /* ErrorCode.APP_OFFLINE */
+      ));
+      return {
+        installationEntry: t,
+        registrationPromise: i
+      };
+    }
+    const n = {
+      fid: t.fid,
+      registrationStatus: 1,
+      registrationTime: Date.now()
+    }, o = Ye(e, n);
+    return { installationEntry: n, registrationPromise: o };
+  } else return t.registrationStatus === 1 ? {
+    installationEntry: t,
+    registrationPromise: ze(e)
+  } : { installationEntry: t };
+}
+async function Ye(e, t) {
+  try {
+    const n = await $e(e, t);
+    return k(e.appConfig, n);
+  } catch (n) {
+    throw oe(n) && n.customData.serverCode === 409 ? await le(e.appConfig) : await k(e.appConfig, {
+      fid: t.fid,
+      registrationStatus: 0
+      /* RequestStatus.NOT_STARTED */
+    }), n;
+  }
+}
+async function ze(e) {
+  let t = await B(e.appConfig);
+  for (; t.registrationStatus === 1; )
+    await ue(100), t = await B(e.appConfig);
+  if (t.registrationStatus === 0) {
+    const { installationEntry: n, registrationPromise: o } = await F(e);
+    return o || n;
+  }
+  return t;
+}
+function B(e) {
+  return S(e, (t) => {
+    if (!t)
+      throw g.create(
+        "installation-not-found"
+        /* ErrorCode.INSTALLATION_NOT_FOUND */
+      );
+    return ge(t);
+  });
+}
+function ge(e) {
+  return Xe(e) ? {
+    fid: e.fid,
+    registrationStatus: 0
+    /* RequestStatus.NOT_STARTED */
+  } : e;
+}
+function Xe(e) {
+  return e.registrationStatus === 1 && e.registrationTime + ee < Date.now();
+}
+async function Qe({ appConfig: e, heartbeatServiceProvider: t }, n) {
+  const o = Ze(e, n), i = Pe(e, n), r = t.getImmediate({
+    optional: !0
+  });
+  if (r) {
+    const d = await r.getHeartbeatsHeader();
+    d && i.append("x-firebase-client", d);
+  }
+  const a = {
+    installation: {
+      sdkVersion: te,
+      appId: e.appId
+    }
+  }, c = {
+    method: "POST",
+    headers: i,
+    body: JSON.stringify(a)
+  }, f = await ce(() => fetch(o, c));
+  if (f.ok) {
+    const d = await f.json();
+    return re(d);
+  } else
+    throw await ae("Generate Auth Token", f);
+}
+function Ze(e, { fid: t }) {
+  return `${ie(e)}/${t}/authTokens:generate`;
+}
+async function $(e, t = !1) {
+  let n;
+  const o = await S(e.appConfig, (r) => {
+    if (!we(r))
+      throw g.create(
+        "not-registered"
+        /* ErrorCode.NOT_REGISTERED */
+      );
+    const a = r.authToken;
+    if (!t && nt(a))
+      return r;
+    if (a.requestStatus === 1)
+      return n = et(e, t), r;
+    {
+      if (!navigator.onLine)
+        throw g.create(
+          "app-offline"
+          /* ErrorCode.APP_OFFLINE */
+        );
+      const c = it(r);
+      return n = tt(e, c), c;
+    }
+  });
+  return n ? await n : o.authToken;
+}
+async function et(e, t) {
+  let n = await H(e.appConfig);
+  for (; n.authToken.requestStatus === 1; )
+    await ue(100), n = await H(e.appConfig);
+  const o = n.authToken;
+  return o.requestStatus === 0 ? $(e, t) : o;
+}
+function H(e) {
+  return S(e, (t) => {
+    if (!we(t))
+      throw g.create(
+        "not-registered"
+        /* ErrorCode.NOT_REGISTERED */
+      );
+    const n = t.authToken;
+    return rt(n) ? Object.assign(Object.assign({}, t), { authToken: {
+      requestStatus: 0
+      /* RequestStatus.NOT_STARTED */
+    } }) : t;
+  });
+}
+async function tt(e, t) {
+  try {
+    const n = await Qe(e, t), o = Object.assign(Object.assign({}, t), { authToken: n });
+    return await k(e.appConfig, o), n;
+  } catch (n) {
+    if (oe(n) && (n.customData.serverCode === 401 || n.customData.serverCode === 404))
+      await le(e.appConfig);
+    else {
+      const o = Object.assign(Object.assign({}, t), { authToken: {
+        requestStatus: 0
+        /* RequestStatus.NOT_STARTED */
+      } });
+      await k(e.appConfig, o);
+    }
+    throw n;
+  }
+}
+function we(e) {
+  return e !== void 0 && e.registrationStatus === 2;
+}
+function nt(e) {
+  return e.requestStatus === 2 && !ot(e);
+}
+function ot(e) {
+  const t = Date.now();
+  return t < e.creationTime || e.creationTime + e.expiresIn < t + Ne;
+}
+function it(e) {
+  const t = {
+    requestStatus: 1,
+    requestTime: Date.now()
+  };
+  return Object.assign(Object.assign({}, e), { authToken: t });
+}
+function rt(e) {
+  return e.requestStatus === 1 && e.requestTime + ee < Date.now();
+}
+async function at(e) {
+  const t = e, { installationEntry: n, registrationPromise: o } = await F(t);
+  return o ? o.catch(console.error) : $(t).catch(console.error), n.fid;
+}
+async function st(e, t = !1) {
+  const n = e;
+  return await ct(n), (await $(n, t)).token;
+}
+async function ct(e) {
+  const { registrationPromise: t } = await F(e);
+  t && await t;
+}
+function ut(e) {
+  if (!e || !e.options)
+    throw _("App Configuration");
+  if (!e.name)
+    throw _("App Name");
+  const t = [
+    "projectId",
+    "apiKey",
+    "appId"
+  ];
+  for (const n of t)
+    if (!e.options[n])
+      throw _(n);
+  return {
+    appName: e.name,
+    projectId: e.options.projectId,
+    apiKey: e.options.apiKey,
+    appId: e.options.appId
+  };
+}
+function _(e) {
+  return g.create("missing-app-config-values", {
+    valueName: e
+  });
+}
+const he = "installations", dt = "installations-internal", ft = (e) => {
+  const t = e.getProvider("app").getImmediate(), n = ut(t), o = R(t, "heartbeat");
+  return {
+    app: t,
+    appConfig: n,
+    heartbeatServiceProvider: o,
+    _delete: () => Promise.resolve()
+  };
+}, pt = (e) => {
+  const t = e.getProvider("app").getImmediate(), n = R(t, he).getImmediate();
+  return {
+    getId: () => at(n),
+    getToken: (i) => st(n, i)
+  };
+};
+function lt() {
+  y(new T(
+    he,
+    ft,
+    "PUBLIC"
+    /* ComponentType.PUBLIC */
+  )), y(new T(
+    dt,
+    pt,
+    "PRIVATE"
+    /* ComponentType.PRIVATE */
+  ));
+}
+lt();
+m(Z, P);
+m(Z, P, "esm2017");
+const gt = "/firebase-messaging-sw.js", wt = "/firebase-cloud-messaging-push-scope", be = "BDOU99-h67HcA6JeFXHbSNMu7e2yNNu3RzoMj8TM4W88jITfq7ZmPvIM1Iv-4_l2LxQcYwhqby2xGpWwzjfAnG4", ht = "https://fcmregistrations.googleapis.com/v1", me = "google.c.a.c_id", bt = "google.c.a.c_l", mt = "google.c.a.ts", yt = "google.c.a.e", W = 1e4;
+var U;
+(function(e) {
+  e[e.DATA_MESSAGE = 1] = "DATA_MESSAGE", e[e.DISPLAY_NOTIFICATION = 3] = "DISPLAY_NOTIFICATION";
+})(U || (U = {}));
+var b;
+(function(e) {
+  e.PUSH_RECEIVED = "push-received", e.NOTIFICATION_CLICKED = "notification-clicked";
+})(b || (b = {}));
+function p(e) {
+  const t = new Uint8Array(e);
+  return btoa(String.fromCharCode(...t)).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+}
+function Tt(e) {
+  const t = "=".repeat((4 - e.length % 4) % 4), n = (e + t).replace(/\-/g, "+").replace(/_/g, "/"), o = atob(n), i = new Uint8Array(o.length);
+  for (let r = 0; r < o.length; ++r)
+    i[r] = o.charCodeAt(r);
+  return i;
+}
+const O = "fcm_token_details_db", kt = 5, G = "fcm_token_object_Store";
+async function It(e) {
+  if ("databases" in indexedDB && !(await indexedDB.databases()).map((r) => r.name).includes(O))
+    return null;
+  let t = null;
+  return (await M(O, kt, {
+    upgrade: async (o, i, r, a) => {
+      var c;
+      if (i < 2 || !o.objectStoreNames.contains(G))
+        return;
+      const f = a.objectStore(G), d = await f.index("fcmSenderId").get(e);
+      if (await f.clear(), !!d) {
+        if (i === 2) {
+          const s = d;
+          if (!s.auth || !s.p256dh || !s.endpoint)
+            return;
+          t = {
+            token: s.fcmToken,
+            createTime: (c = s.createTime) !== null && c !== void 0 ? c : Date.now(),
+            subscriptionOptions: {
+              auth: s.auth,
+              p256dh: s.p256dh,
+              endpoint: s.endpoint,
+              swScope: s.swScope,
+              vapidKey: typeof s.vapidKey == "string" ? s.vapidKey : p(s.vapidKey)
+            }
+          };
+        } else if (i === 3) {
+          const s = d;
+          t = {
+            token: s.fcmToken,
+            createTime: s.createTime,
+            subscriptionOptions: {
+              auth: p(s.auth),
+              p256dh: p(s.p256dh),
+              endpoint: s.endpoint,
+              swScope: s.swScope,
+              vapidKey: p(s.vapidKey)
+            }
+          };
+        } else if (i === 4) {
+          const s = d;
+          t = {
+            token: s.fcmToken,
+            createTime: s.createTime,
+            subscriptionOptions: {
+              auth: p(s.auth),
+              p256dh: p(s.p256dh),
+              endpoint: s.endpoint,
+              swScope: s.swScope,
+              vapidKey: p(s.vapidKey)
+            }
+          };
+        }
+      }
+    }
+  })).close(), await A(O), await A("fcm_vapid_details_db"), await A("undefined"), vt(t) ? t : null;
+}
+function vt(e) {
+  if (!e || !e.subscriptionOptions)
+    return !1;
+  const { subscriptionOptions: t } = e;
+  return typeof e.createTime == "number" && e.createTime > 0 && typeof e.token == "string" && e.token.length > 0 && typeof t.auth == "string" && t.auth.length > 0 && typeof t.p256dh == "string" && t.p256dh.length > 0 && typeof t.endpoint == "string" && t.endpoint.length > 0 && typeof t.swScope == "string" && t.swScope.length > 0 && typeof t.vapidKey == "string" && t.vapidKey.length > 0;
+}
+const St = "firebase-messaging-database", At = 1, h = "firebase-messaging-store";
+let C = null;
+function K() {
+  return C || (C = M(St, At, {
+    upgrade: (e, t) => {
+      t === 0 && e.createObjectStore(h);
+    }
+  })), C;
+}
+async function ye(e) {
+  const t = L(e), o = await (await K()).transaction(h).objectStore(h).get(t);
+  if (o)
+    return o;
+  {
+    const i = await It(e.appConfig.senderId);
+    if (i)
+      return await q(e, i), i;
+  }
+}
+async function q(e, t) {
+  const n = L(e), i = (await K()).transaction(h, "readwrite");
+  return await i.objectStore(h).put(t, n), await i.done, t;
+}
+async function Et(e) {
+  const t = L(e), o = (await K()).transaction(h, "readwrite");
+  await o.objectStore(h).delete(t), await o.done;
+}
+function L({ appConfig: e }) {
+  return e.appId;
+}
+const _t = {
+  "missing-app-config-values": 'Missing App configuration value: "{$valueName}"',
+  "only-available-in-window": "This method is available in a Window context.",
+  "only-available-in-sw": "This method is available in a service worker context.",
+  "permission-default": "The notification permission was not granted and dismissed instead.",
+  "permission-blocked": "The notification permission was not granted and blocked instead.",
+  "unsupported-browser": "This browser doesn't support the API's required to use the Firebase SDK.",
+  "indexed-db-unsupported": "This browser doesn't support indexedDb.open() (ex. Safari iFrame, Firefox Private Browsing, etc)",
+  "failed-service-worker-registration": "We are unable to register the default service worker. {$browserErrorMessage}",
+  "token-subscribe-failed": "A problem occurred while subscribing the user to FCM: {$errorInfo}",
+  "token-subscribe-no-token": "FCM returned no token when subscribing the user to push.",
+  "token-unsubscribe-failed": "A problem occurred while unsubscribing the user from FCM: {$errorInfo}",
+  "token-update-failed": "A problem occurred while updating the user from FCM: {$errorInfo}",
+  "token-update-no-token": "FCM returned no token when updating the user to push.",
+  "use-sw-after-get-token": "The useServiceWorker() method may only be called once and must be called before calling getToken() to ensure your service worker is used.",
+  "invalid-sw-registration": "The input to useServiceWorker() must be a ServiceWorkerRegistration.",
+  "invalid-bg-handler": "The input to setBackgroundMessageHandler() must be a function.",
+  "invalid-vapid-key": "The public VAPID key must be a string.",
+  "use-vapid-key-after-get-token": "The usePublicVapidKey() method may only be called once and must be called before calling getToken() to ensure your VAPID key is used."
+}, u = new Q("messaging", "Messaging", _t);
+async function Ot(e, t) {
+  const n = await V(e), o = ke(t), i = {
+    method: "POST",
+    headers: n,
+    body: JSON.stringify(o)
+  };
+  let r;
+  try {
+    r = await (await fetch(x(e.appConfig), i)).json();
+  } catch (a) {
+    throw u.create("token-subscribe-failed", {
+      errorInfo: a?.toString()
+    });
+  }
+  if (r.error) {
+    const a = r.error.message;
+    throw u.create("token-subscribe-failed", {
+      errorInfo: a
+    });
+  }
+  if (!r.token)
+    throw u.create(
+      "token-subscribe-no-token"
+      /* ErrorCode.TOKEN_SUBSCRIBE_NO_TOKEN */
+    );
+  return r.token;
+}
+async function Ct(e, t) {
+  const n = await V(e), o = ke(t.subscriptionOptions), i = {
+    method: "PATCH",
+    headers: n,
+    body: JSON.stringify(o)
+  };
+  let r;
+  try {
+    r = await (await fetch(`${x(e.appConfig)}/${t.token}`, i)).json();
+  } catch (a) {
+    throw u.create("token-update-failed", {
+      errorInfo: a?.toString()
+    });
+  }
+  if (r.error) {
+    const a = r.error.message;
+    throw u.create("token-update-failed", {
+      errorInfo: a
+    });
+  }
+  if (!r.token)
+    throw u.create(
+      "token-update-no-token"
+      /* ErrorCode.TOKEN_UPDATE_NO_TOKEN */
+    );
+  return r.token;
+}
+async function Te(e, t) {
+  const o = {
+    method: "DELETE",
+    headers: await V(e)
+  };
+  try {
+    const r = await (await fetch(`${x(e.appConfig)}/${t}`, o)).json();
+    if (r.error) {
+      const a = r.error.message;
+      throw u.create("token-unsubscribe-failed", {
+        errorInfo: a
+      });
+    }
+  } catch (i) {
+    throw u.create("token-unsubscribe-failed", {
+      errorInfo: i?.toString()
+    });
+  }
+}
+function x({ projectId: e }) {
+  return `${ht}/projects/${e}/registrations`;
+}
+async function V({ appConfig: e, installations: t }) {
+  const n = await t.getToken();
+  return new Headers({
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-goog-api-key": e.apiKey,
+    "x-goog-firebase-installations-auth": `FIS ${n}`
+  });
+}
+function ke({ p256dh: e, auth: t, endpoint: n, vapidKey: o }) {
+  const i = {
+    web: {
+      endpoint: n,
+      auth: t,
+      p256dh: e
+    }
+  };
+  return o !== be && (i.web.applicationPubKey = o), i;
+}
+const Nt = 10080 * 60 * 1e3;
+async function Dt(e) {
+  const t = await Pt(e.swRegistration, e.vapidKey), n = {
+    vapidKey: e.vapidKey,
+    swScope: e.swRegistration.scope,
+    endpoint: t.endpoint,
+    auth: p(t.getKey("auth")),
+    p256dh: p(t.getKey("p256dh"))
+  }, o = await ye(e.firebaseDependencies);
+  if (o) {
+    if (jt(o.subscriptionOptions, n))
+      return Date.now() >= o.createTime + Nt ? Mt(e, {
+        token: o.token,
+        createTime: Date.now(),
+        subscriptionOptions: n
+      }) : o.token;
+    try {
+      await Te(e.firebaseDependencies, o.token);
+    } catch (i) {
+      console.warn(i);
+    }
+    return J(e.firebaseDependencies, n);
+  } else return J(e.firebaseDependencies, n);
+}
+async function Rt(e) {
+  const t = await ye(e.firebaseDependencies);
+  t && (await Te(e.firebaseDependencies, t.token), await Et(e.firebaseDependencies));
+  const n = await e.swRegistration.pushManager.getSubscription();
+  return n ? n.unsubscribe() : !0;
+}
+async function Mt(e, t) {
+  try {
+    const n = await Ct(e.firebaseDependencies, t), o = Object.assign(Object.assign({}, t), { token: n, createTime: Date.now() });
+    return await q(e.firebaseDependencies, o), n;
+  } catch (n) {
+    throw n;
+  }
+}
+async function J(e, t) {
+  const o = {
+    token: await Ot(e, t),
+    createTime: Date.now(),
+    subscriptionOptions: t
+  };
+  return await q(e, o), o.token;
+}
+async function Pt(e, t) {
+  const n = await e.pushManager.getSubscription();
+  return n || e.pushManager.subscribe({
+    userVisibleOnly: !0,
+    // Chrome <= 75 doesn't support base64-encoded VAPID key. For backward compatibility, VAPID key
+    // submitted to pushManager#subscribe must be of type Uint8Array.
+    applicationServerKey: Tt(t)
+  });
+}
+function jt(e, t) {
+  const n = t.vapidKey === e.vapidKey, o = t.endpoint === e.endpoint, i = t.auth === e.auth, r = t.p256dh === e.p256dh;
+  return n && o && i && r;
+}
+function Y(e) {
+  const t = {
+    from: e.from,
+    // eslint-disable-next-line camelcase
+    collapseKey: e.collapse_key,
+    // eslint-disable-next-line camelcase
+    messageId: e.fcmMessageId
+  };
+  return Ft(t, e), $t(t, e), Kt(t, e), t;
+}
+function Ft(e, t) {
+  if (!t.notification)
+    return;
+  e.notification = {};
+  const n = t.notification.title;
+  n && (e.notification.title = n);
+  const o = t.notification.body;
+  o && (e.notification.body = o);
+  const i = t.notification.image;
+  i && (e.notification.image = i);
+  const r = t.notification.icon;
+  r && (e.notification.icon = r);
+}
+function $t(e, t) {
+  t.data && (e.data = t.data);
+}
+function Kt(e, t) {
+  var n, o, i, r, a;
+  if (!t.fcmOptions && !(!((n = t.notification) === null || n === void 0) && n.click_action))
+    return;
+  e.fcmOptions = {};
+  const c = (i = (o = t.fcmOptions) === null || o === void 0 ? void 0 : o.link) !== null && i !== void 0 ? i : (r = t.notification) === null || r === void 0 ? void 0 : r.click_action;
+  c && (e.fcmOptions.link = c);
+  const f = (a = t.fcmOptions) === null || a === void 0 ? void 0 : a.analytics_label;
+  f && (e.fcmOptions.analyticsLabel = f);
+}
+function qt(e) {
+  return typeof e == "object" && !!e && me in e;
+}
+function Lt(e) {
+  if (!e || !e.options)
+    throw N("App Configuration Object");
+  if (!e.name)
+    throw N("App Name");
+  const t = [
+    "projectId",
+    "apiKey",
+    "appId",
+    "messagingSenderId"
+  ], { options: n } = e;
+  for (const o of t)
+    if (!n[o])
+      throw N(o);
+  return {
+    appName: e.name,
+    projectId: n.projectId,
+    apiKey: n.apiKey,
+    appId: n.appId,
+    senderId: n.messagingSenderId
+  };
+}
+function N(e) {
+  return u.create("missing-app-config-values", {
+    valueName: e
+  });
+}
+class xt {
+  constructor(t, n, o) {
+    this.deliveryMetricsExportedToBigQueryEnabled = !1, this.onBackgroundMessageHandler = null, this.onMessageHandler = null, this.logEvents = [], this.isLogServiceStarted = !1;
+    const i = Lt(t);
+    this.firebaseDependencies = {
+      app: t,
+      appConfig: i,
+      installations: n,
+      analyticsProvider: o
+    };
+  }
+  _delete() {
+    return Promise.resolve();
+  }
+}
+async function Ie(e) {
+  try {
+    e.swRegistration = await navigator.serviceWorker.register(gt, {
+      scope: wt
+    }), e.swRegistration.update().catch(() => {
+    }), await Vt(e.swRegistration);
+  } catch (t) {
+    throw u.create("failed-service-worker-registration", {
+      browserErrorMessage: t?.message
+    });
+  }
+}
+async function Vt(e) {
+  return new Promise((t, n) => {
+    const o = setTimeout(() => n(new Error(`Service worker not registered after ${W} ms`)), W), i = e.installing || e.waiting;
+    e.active ? (clearTimeout(o), t()) : i ? i.onstatechange = (r) => {
+      var a;
+      ((a = r.target) === null || a === void 0 ? void 0 : a.state) === "activated" && (i.onstatechange = null, clearTimeout(o), t());
+    } : (clearTimeout(o), n(new Error("No incoming service worker found.")));
+  });
+}
+async function Bt(e, t) {
+  if (!t && !e.swRegistration && await Ie(e), !(!t && e.swRegistration)) {
+    if (!(t instanceof ServiceWorkerRegistration))
+      throw u.create(
+        "invalid-sw-registration"
+        /* ErrorCode.INVALID_SW_REGISTRATION */
+      );
+    e.swRegistration = t;
+  }
+}
+async function Ht(e, t) {
+  t ? e.vapidKey = t : e.vapidKey || (e.vapidKey = be);
+}
+async function ve(e, t) {
+  if (!navigator)
+    throw u.create(
+      "only-available-in-window"
+      /* ErrorCode.AVAILABLE_IN_WINDOW */
+    );
+  if (Notification.permission === "default" && await Notification.requestPermission(), Notification.permission !== "granted")
+    throw u.create(
+      "permission-blocked"
+      /* ErrorCode.PERMISSION_BLOCKED */
+    );
+  return await Ht(e, t?.vapidKey), await Bt(e, t?.serviceWorkerRegistration), Dt(e);
+}
+async function Wt(e, t, n) {
+  const o = Ut(t);
+  (await e.firebaseDependencies.analyticsProvider.get()).logEvent(o, {
+    /* eslint-disable camelcase */
+    message_id: n[me],
+    message_name: n[bt],
+    message_time: n[mt],
+    message_device_time: Math.floor(Date.now() / 1e3)
+    /* eslint-enable camelcase */
+  });
+}
+function Ut(e) {
+  switch (e) {
+    case b.NOTIFICATION_CLICKED:
+      return "notification_open";
+    case b.PUSH_RECEIVED:
+      return "notification_foreground";
+    default:
+      throw new Error();
+  }
+}
+async function Gt(e, t) {
+  const n = t.data;
+  if (!n.isFirebaseMessaging)
+    return;
+  e.onMessageHandler && n.messageType === b.PUSH_RECEIVED && (typeof e.onMessageHandler == "function" ? e.onMessageHandler(Y(n)) : e.onMessageHandler.next(Y(n)));
+  const o = n.data;
+  qt(o) && o[yt] === "1" && await Wt(e, n.messageType, o);
+}
+const z = "@firebase/messaging", X = "0.12.21";
+const Jt = (e) => {
+  const t = new xt(e.getProvider("app").getImmediate(), e.getProvider("installations-internal").getImmediate(), e.getProvider("analytics-internal"));
+  return navigator.serviceWorker.addEventListener("message", (n) => Gt(t, n)), t;
+}, Yt = (e) => {
+  const t = e.getProvider("messaging").getImmediate();
+  return {
+    getToken: (o) => ve(t, o)
+  };
+};
+function zt() {
+  y(new T(
+    "messaging",
+    Jt,
+    "PUBLIC"
+    /* ComponentType.PUBLIC */
+  )), y(new T(
+    "messaging-internal",
+    Yt,
+    "PRIVATE"
+    /* ComponentType.PRIVATE */
+  )), m(z, X), m(z, X, "esm2017");
+}
+async function Xt() {
+  try {
+    await Ee();
+  } catch {
+    return !1;
+  }
+  return typeof window < "u" && _e() && Oe() && "serviceWorker" in navigator && "PushManager" in window && "Notification" in window && "fetch" in window && ServiceWorkerRegistration.prototype.hasOwnProperty("showNotification") && PushSubscription.prototype.hasOwnProperty("getKey");
+}
+async function Qt(e) {
+  if (!navigator)
+    throw u.create(
+      "only-available-in-window"
+      /* ErrorCode.AVAILABLE_IN_WINDOW */
+    );
+  return e.swRegistration || await Ie(e), Rt(e);
+}
+function Zt(e, t) {
+  if (!navigator)
+    throw u.create(
+      "only-available-in-window"
+      /* ErrorCode.AVAILABLE_IN_WINDOW */
+    );
+  return e.onMessageHandler = t, () => {
+    e.onMessageHandler = null;
+  };
+}
+function tn(e = Ae()) {
+  return Xt().then((t) => {
+    if (!t)
+      throw u.create(
+        "unsupported-browser"
+        /* ErrorCode.UNSUPPORTED_BROWSER */
+      );
+  }, (t) => {
+    throw u.create(
+      "indexed-db-unsupported"
+      /* ErrorCode.INDEXED_DB_UNSUPPORTED */
+    );
+  }), R(I(e), "messaging").getImmediate();
+}
+async function nn(e, t) {
+  return e = I(e), ve(e, t);
+}
+function on(e) {
+  return e = I(e), Qt(e);
+}
+function rn(e, t) {
+  return e = I(e), Zt(e, t);
+}
+zt();
+export {
+  on as deleteToken,
+  tn as getMessaging,
+  nn as getToken,
+  Xt as isSupported,
+  rn as onMessage
+};