@useknest/widget-core 0.0.1-alpha.3 → 0.0.1-alpha.4

package/dist/index.js

@@ -1,98 +1,4264 @@
-import { marked as E } from "marked";
-const g = "http://localhost:5173/api/v1", y = `${g}/chat-messages`, m = `${g}/widget-config`, I = "Sorry, I didn't get a response.", u = "Unknown error occurred", R = "/default-avatar.svg", S = "#0d7a7f", L = "Hi! I'm your AI assistant. I'm trained to answer questions about your documentation. How can I help you today?", C = [
+import { marked as Qe } from "marked";
+const tn = "https://useknest.com", en = "/api/v1";
+function Wn(t = tn) {
+  return `${t}${en}/chat-messages`;
+}
+function qn(t = tn) {
+  return `${t}${en}/widget-config`;
+}
+const Yn = "Sorry, I didn't get a response.", ie = "Unknown error occurred", Ra = "/default-avatar.svg", ka = "#0d7a7f", Aa = "Hi! I'm your AI assistant. I'm trained to answer questions about your documentation. How can I help you today?", xa = [
   "How do I get started?",
   "What features are available?",
   "How do I integrate this?"
 ];
-async function T(n) {
+async function Oa(t, e) {
   try {
-    const t = await fetch(m, {
+    const n = await fetch(qn(e), {
       method: "GET",
       headers: {
-        "X-Api-Key": n
+        "X-Api-Key": t
       }
     });
-    if (t.ok)
-      return await t.json();
+    if (n.ok)
+      return await n.json();
     {
-      const r = await t.text();
-      return console.warn("Failed to fetch widget config:", t.status, r), null;
+      const r = await n.text();
+      return console.warn("Failed to fetch widget config:", n.status, r), null;
     }
-  } catch (t) {
-    return console.error("Error fetching widget config:", t), null;
+  } catch (n) {
+    return console.error("Error fetching widget config:", n), null;
   }
 }
-async function b(n) {
-  const { publishableApiKey: t, content: r, threadId: l, callbacks: o } = n;
+async function Na(t) {
+  const { publishableApiKey: e, content: n, threadId: r, callbacks: s, baseUrl: o } = t;
   try {
-    const a = { content: r };
-    l && (a.threadId = l);
-    const s = await fetch(y, {
+    const i = { content: n };
+    r && (i.threadId = r);
+    const a = await fetch(Wn(o), {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "X-Api-Key": t
+        "X-Api-Key": e
       },
-      body: JSON.stringify(a)
+      body: JSON.stringify(i)
     });
-    if (!s.ok) {
-      const c = await s.json();
-      throw new Error(c.error || "Failed to send message");
+    if (!a.ok) {
+      const m = await a.json();
+      throw new Error(m.error || "Failed to send message");
     }
-    const f = s.body?.getReader();
-    if (!f)
+    const c = a.body?.getReader();
+    if (!c)
       throw new Error("Response body is not readable");
-    const A = new TextDecoder();
-    let i = "", p = !1;
+    const u = new TextDecoder();
+    let f = "", l = !1;
     for (; ; ) {
-      const { done: c, value: w } = await f.read();
-      if (c) break;
-      i += A.decode(w, { stream: !0 });
-      const h = i.split(`
+      const { done: m, value: d } = await c.read();
+      if (m) break;
+      f += u.decode(d, { stream: !0 });
+      const E = f.split(`
 `);
-      i = h.pop() || "";
-      for (const d of h)
-        if (d.startsWith("data: "))
+      f = E.pop() || "";
+      for (const R of E)
+        if (R.startsWith("data: "))
           try {
-            const e = JSON.parse(d.slice(6));
-            if (e.type === "init")
-              e.threadId && o.onInit && o.onInit(e.threadId);
-            else if (e.type === "content")
-              e.content && (p = !0, o.onContent(e.content));
-            else if (e.type === "complete")
-              o.onComplete && o.onComplete(e.sources || []);
-            else if (e.type === "error")
-              throw new Error(e.error || u);
-          } catch (e) {
-            console.error("Error parsing SSE data:", e, d);
+            const g = JSON.parse(R.slice(6));
+            if (g.type === "init")
+              g.threadId && s.onInit && s.onInit(g.threadId);
+            else if (g.type === "content")
+              g.content && (l = !0, s.onContent(g.content));
+            else if (g.type === "complete")
+              s.onComplete && s.onComplete(g.sources || []);
+            else if (g.type === "error")
+              throw new Error(g.error || ie);
+          } catch (g) {
+            console.error("Error parsing SSE data:", g, R);
           }
     }
-    p || o.onError(I);
-  } catch (a) {
-    const s = a instanceof Error ? a.message : u;
-    o.onError(s);
+    l || s.onError(Yn);
+  } catch (i) {
+    const a = i instanceof Error ? i.message : ie;
+    s.onError(a);
   }
 }
-E.setOptions({
+Qe.setOptions({
   breaks: !0,
   gfm: !0
 });
-function O(n) {
-  return n.split(/\n\s*\n/).map((r) => r.trim()).filter((r) => r).map((r) => ({
-    html: E.parseInline(r)
+function Ca(t) {
+  return t.split(/\n\s*\n/).map((n) => n.trim()).filter((n) => n).map((n) => ({
+    html: Qe.parseInline(n)
+  }));
+}
+const h = typeof __SENTRY_DEBUG__ > "u" || __SENTRY_DEBUG__, _ = globalThis, P = "9.47.1";
+function mt() {
+  return gt(_), _;
+}
+function gt(t) {
+  const e = t.__SENTRY__ = t.__SENTRY__ || {};
+  return e.version = e.version || P, e[P] = e[P] || {};
+}
+function J(t, e, n = _) {
+  const r = n.__SENTRY__ = n.__SENTRY__ || {}, s = r[P] = r[P] || {};
+  return s[t] || (s[t] = e());
+}
+const zn = [
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "log",
+  "assert",
+  "trace"
+], Xn = "Sentry Logger ", lt = {};
+function Y(t) {
+  if (!("console" in _))
+    return t();
+  const e = _.console, n = {}, r = Object.keys(lt);
+  r.forEach((s) => {
+    const o = lt[s];
+    n[s] = e[s], e[s] = o;
+  });
+  try {
+    return t();
+  } finally {
+    r.forEach((s) => {
+      e[s] = n[s];
+    });
+  }
+}
+function Kn() {
+  Yt().enabled = !0;
+}
+function Vn() {
+  Yt().enabled = !1;
+}
+function nn() {
+  return Yt().enabled;
+}
+function Jn(...t) {
+  qt("log", ...t);
+}
+function Zn(...t) {
+  qt("warn", ...t);
+}
+function Qn(...t) {
+  qt("error", ...t);
+}
+function qt(t, ...e) {
+  h && nn() && Y(() => {
+    _.console[t](`${Xn}[${t}]:`, ...e);
+  });
+}
+function Yt() {
+  return h ? J("loggerSettings", () => ({ enabled: !1 })) : { enabled: !1 };
+}
+const p = {
+  /** Enable logging. */
+  enable: Kn,
+  /** Disable logging. */
+  disable: Vn,
+  /** Check if logging is enabled. */
+  isEnabled: nn,
+  /** Log a message. */
+  log: Jn,
+  /** Log a warning. */
+  warn: Zn,
+  /** Log an error. */
+  error: Qn
+}, rn = 50, M = "?", ae = /\(error: (.*)\)/, ce = /captureMessage|captureException/;
+function sn(...t) {
+  const e = t.sort((n, r) => n[0] - r[0]).map((n) => n[1]);
+  return (n, r = 0, s = 0) => {
+    const o = [], i = n.split(`
+`);
+    for (let a = r; a < i.length; a++) {
+      const c = i[a];
+      if (c.length > 1024)
+        continue;
+      const u = ae.test(c) ? c.replace(ae, "$1") : c;
+      if (!u.match(/\S*Error: /)) {
+        for (const f of e) {
+          const l = f(u);
+          if (l) {
+            o.push(l);
+            break;
+          }
+        }
+        if (o.length >= rn + s)
+          break;
+      }
+    }
+    return er(o.slice(s));
+  };
+}
+function tr(t) {
+  return Array.isArray(t) ? sn(...t) : t;
+}
+function er(t) {
+  if (!t.length)
+    return [];
+  const e = Array.from(t);
+  return /sentryWrapped/.test(nt(e).function || "") && e.pop(), e.reverse(), ce.test(nt(e).function || "") && (e.pop(), ce.test(nt(e).function || "") && e.pop()), e.slice(0, rn).map((n) => ({
+    ...n,
+    filename: n.filename || nt(e).filename,
+    function: n.function || M
   }));
 }
+function nt(t) {
+  return t[t.length - 1] || {};
+}
+const It = "<anonymous>";
+function O(t) {
+  try {
+    return !t || typeof t != "function" ? It : t.name || It;
+  } catch {
+    return It;
+  }
+}
+function ue(t) {
+  const e = t.exception;
+  if (e) {
+    const n = [];
+    try {
+      return e.values.forEach((r) => {
+        r.stacktrace.frames && n.push(...r.stacktrace.frames);
+      }), n;
+    } catch {
+      return;
+    }
+  }
+}
+const ct = {}, fe = {};
+function j(t, e) {
+  ct[t] = ct[t] || [], ct[t].push(e);
+}
+function B(t, e) {
+  if (!fe[t]) {
+    fe[t] = !0;
+    try {
+      e();
+    } catch (n) {
+      h && p.error(`Error while instrumenting ${t}`, n);
+    }
+  }
+}
+function v(t, e) {
+  const n = t && ct[t];
+  if (n)
+    for (const r of n)
+      try {
+        r(e);
+      } catch (s) {
+        h && p.error(
+          `Error while triggering instrumentation handler.
+Type: ${t}
+Name: ${O(r)}
+Error:`,
+          s
+        );
+      }
+}
+let vt = null;
+function nr(t) {
+  const e = "error";
+  j(e, t), B(e, rr);
+}
+function rr() {
+  vt = _.onerror, _.onerror = function(t, e, n, r, s) {
+    return v("error", {
+      column: r,
+      error: s,
+      line: n,
+      msg: t,
+      url: e
+    }), vt ? vt.apply(this, arguments) : !1;
+  }, _.onerror.__SENTRY_INSTRUMENTED__ = !0;
+}
+let wt = null;
+function sr(t) {
+  const e = "unhandledrejection";
+  j(e, t), B(e, or);
+}
+function or() {
+  wt = _.onunhandledrejection, _.onunhandledrejection = function(t) {
+    return v("unhandledrejection", t), wt ? wt.apply(this, arguments) : !0;
+  }, _.onunhandledrejection.__SENTRY_INSTRUMENTED__ = !0;
+}
+const on = Object.prototype.toString;
+function zt(t) {
+  switch (on.call(t)) {
+    case "[object Error]":
+    case "[object Exception]":
+    case "[object DOMException]":
+    case "[object WebAssembly.Exception]":
+      return !0;
+    default:
+      return N(t, Error);
+  }
+}
+function z(t, e) {
+  return on.call(t) === `[object ${e}]`;
+}
+function an(t) {
+  return z(t, "ErrorEvent");
+}
+function le(t) {
+  return z(t, "DOMError");
+}
+function ir(t) {
+  return z(t, "DOMException");
+}
+function A(t) {
+  return z(t, "String");
+}
+function Xt(t) {
+  return typeof t == "object" && t !== null && "__sentry_template_string__" in t && "__sentry_template_values__" in t;
+}
+function Kt(t) {
+  return t === null || Xt(t) || typeof t != "object" && typeof t != "function";
+}
+function K(t) {
+  return z(t, "Object");
+}
+function _t(t) {
+  return typeof Event < "u" && N(t, Event);
+}
+function ar(t) {
+  return typeof Element < "u" && N(t, Element);
+}
+function cr(t) {
+  return z(t, "RegExp");
+}
+function yt(t) {
+  return !!(t?.then && typeof t.then == "function");
+}
+function ur(t) {
+  return K(t) && "nativeEvent" in t && "preventDefault" in t && "stopPropagation" in t;
+}
+function N(t, e) {
+  try {
+    return t instanceof e;
+  } catch {
+    return !1;
+  }
+}
+function cn(t) {
+  return !!(typeof t == "object" && t !== null && (t.__isVue || t._isVue));
+}
+function fr(t) {
+  return typeof Request < "u" && N(t, Request);
+}
+const Vt = _, lr = 80;
+function un(t, e = {}) {
+  if (!t)
+    return "<unknown>";
+  try {
+    let n = t;
+    const r = 5, s = [];
+    let o = 0, i = 0;
+    const a = " > ", c = a.length;
+    let u;
+    const f = Array.isArray(e) ? e : e.keyAttrs, l = !Array.isArray(e) && e.maxStringLength || lr;
+    for (; n && o++ < r && (u = dr(n, f), !(u === "html" || o > 1 && i + s.length * c + u.length >= l)); )
+      s.push(u), i += u.length, n = n.parentNode;
+    return s.reverse().join(a);
+  } catch {
+    return "<unknown>";
+  }
+}
+function dr(t, e) {
+  const n = t, r = [];
+  if (!n?.tagName)
+    return "";
+  if (Vt.HTMLElement && n instanceof HTMLElement && n.dataset) {
+    if (n.dataset.sentryComponent)
+      return n.dataset.sentryComponent;
+    if (n.dataset.sentryElement)
+      return n.dataset.sentryElement;
+  }
+  r.push(n.tagName.toLowerCase());
+  const s = e?.length ? e.filter((i) => n.getAttribute(i)).map((i) => [i, n.getAttribute(i)]) : null;
+  if (s?.length)
+    s.forEach((i) => {
+      r.push(`[${i[0]}="${i[1]}"]`);
+    });
+  else {
+    n.id && r.push(`#${n.id}`);
+    const i = n.className;
+    if (i && A(i)) {
+      const a = i.split(/\s+/);
+      for (const c of a)
+        r.push(`.${c}`);
+    }
+  }
+  const o = ["aria-label", "type", "name", "title", "alt"];
+  for (const i of o) {
+    const a = n.getAttribute(i);
+    a && r.push(`[${i}="${a}"]`);
+  }
+  return r.join("");
+}
+function Jt() {
+  try {
+    return Vt.document.location.href;
+  } catch {
+    return "";
+  }
+}
+function pr(t) {
+  if (!Vt.HTMLElement)
+    return null;
+  let e = t;
+  const n = 5;
+  for (let r = 0; r < n; r++) {
+    if (!e)
+      return null;
+    if (e instanceof HTMLElement) {
+      if (e.dataset.sentryComponent)
+        return e.dataset.sentryComponent;
+      if (e.dataset.sentryElement)
+        return e.dataset.sentryElement;
+    }
+    e = e.parentNode;
+  }
+  return null;
+}
+function dt(t, e = 0) {
+  return typeof t != "string" || e === 0 || t.length <= e ? t : `${t.slice(0, e)}...`;
+}
+function de(t, e) {
+  if (!Array.isArray(t))
+    return "";
+  const n = [];
+  for (let r = 0; r < t.length; r++) {
+    const s = t[r];
+    try {
+      cn(s) ? n.push("[VueViewModel]") : n.push(String(s));
+    } catch {
+      n.push("[value cannot be serialized]");
+    }
+  }
+  return n.join(e);
+}
+function hr(t, e, n = !1) {
+  return A(t) ? cr(e) ? e.test(t) : A(e) ? n ? t === e : t.includes(e) : !1 : !1;
+}
+function Et(t, e = [], n = !1) {
+  return e.some((r) => hr(t, r, n));
+}
+function T(t, e, n) {
+  if (!(e in t))
+    return;
+  const r = t[e];
+  if (typeof r != "function")
+    return;
+  const s = n(r);
+  typeof s == "function" && fn(s, r);
+  try {
+    t[e] = s;
+  } catch {
+    h && p.log(`Failed to replace method "${e}" in object`, t);
+  }
+}
+function F(t, e, n) {
+  try {
+    Object.defineProperty(t, e, {
+      // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it
+      value: n,
+      writable: !0,
+      configurable: !0
+    });
+  } catch {
+    h && p.log(`Failed to add non-enumerable property "${e}" to object`, t);
+  }
+}
+function fn(t, e) {
+  try {
+    const n = e.prototype || {};
+    t.prototype = e.prototype = n, F(t, "__sentry_original__", e);
+  } catch {
+  }
+}
+function Zt(t) {
+  return t.__sentry_original__;
+}
+function ln(t) {
+  if (zt(t))
+    return {
+      message: t.message,
+      name: t.name,
+      stack: t.stack,
+      ...he(t)
+    };
+  if (_t(t)) {
+    const e = {
+      type: t.type,
+      target: pe(t.target),
+      currentTarget: pe(t.currentTarget),
+      ...he(t)
+    };
+    return typeof CustomEvent < "u" && N(t, CustomEvent) && (e.detail = t.detail), e;
+  } else
+    return t;
+}
+function pe(t) {
+  try {
+    return ar(t) ? un(t) : Object.prototype.toString.call(t);
+  } catch {
+    return "<unknown>";
+  }
+}
+function he(t) {
+  if (typeof t == "object" && t !== null) {
+    const e = {};
+    for (const n in t)
+      Object.prototype.hasOwnProperty.call(t, n) && (e[n] = t[n]);
+    return e;
+  } else
+    return {};
+}
+function mr(t, e = 40) {
+  const n = Object.keys(ln(t));
+  n.sort();
+  const r = n[0];
+  if (!r)
+    return "[object has no keys]";
+  if (r.length >= e)
+    return dt(r, e);
+  for (let s = n.length; s > 0; s--) {
+    const o = n.slice(0, s).join(", ");
+    if (!(o.length > e))
+      return s === n.length ? o : dt(o, e);
+  }
+  return "";
+}
+function gr() {
+  const t = _;
+  return t.crypto || t.msCrypto;
+}
+function I(t = gr()) {
+  let e = () => Math.random() * 16;
+  try {
+    if (t?.randomUUID)
+      return t.randomUUID().replace(/-/g, "");
+    t?.getRandomValues && (e = () => {
+      const n = new Uint8Array(1);
+      return t.getRandomValues(n), n[0];
+    });
+  } catch {
+  }
+  return ("10000000100040008000" + 1e11).replace(
+    /[018]/g,
+    (n) => (
+      // eslint-disable-next-line no-bitwise
+      (n ^ (e() & 15) >> n / 4).toString(16)
+    )
+  );
+}
+function dn(t) {
+  return t.exception?.values?.[0];
+}
+function L(t) {
+  const { message: e, event_id: n } = t;
+  if (e)
+    return e;
+  const r = dn(t);
+  return r ? r.type && r.value ? `${r.type}: ${r.value}` : r.type || r.value || n || "<unknown>" : n || "<unknown>";
+}
+function Nt(t, e, n) {
+  const r = t.exception = t.exception || {}, s = r.values = r.values || [], o = s[0] = s[0] || {};
+  o.value || (o.value = e || ""), o.type || (o.type = "Error");
+}
+function H(t, e) {
+  const n = dn(t);
+  if (!n)
+    return;
+  const r = { type: "generic", handled: !0 }, s = n.mechanism;
+  if (n.mechanism = { ...r, ...s, ...e }, e && "data" in e) {
+    const o = { ...s?.data, ...e.data };
+    n.mechanism.data = o;
+  }
+}
+function me(t) {
+  if (_r(t))
+    return !0;
+  try {
+    F(t, "__sentry_captured__", !0);
+  } catch {
+  }
+  return !1;
+}
+function _r(t) {
+  try {
+    return t.__sentry_captured__;
+  } catch {
+  }
+}
+const pn = 1e3;
+function Z() {
+  return Date.now() / pn;
+}
+function yr() {
+  const { performance: t } = _;
+  if (!t?.now || !t.timeOrigin)
+    return Z;
+  const e = t.timeOrigin;
+  return () => (e + t.now()) / pn;
+}
+let ge;
+function x() {
+  return (ge ?? (ge = yr()))();
+}
+function Er(t) {
+  const e = x(), n = {
+    sid: I(),
+    init: !0,
+    timestamp: e,
+    started: e,
+    duration: 0,
+    status: "ok",
+    errors: 0,
+    ignoreDuration: !1,
+    toJSON: () => br(n)
+  };
+  return t && G(n, t), n;
+}
+function G(t, e = {}) {
+  if (e.user && (!t.ipAddress && e.user.ip_address && (t.ipAddress = e.user.ip_address), !t.did && !e.did && (t.did = e.user.id || e.user.email || e.user.username)), t.timestamp = e.timestamp || x(), e.abnormal_mechanism && (t.abnormal_mechanism = e.abnormal_mechanism), e.ignoreDuration && (t.ignoreDuration = e.ignoreDuration), e.sid && (t.sid = e.sid.length === 32 ? e.sid : I()), e.init !== void 0 && (t.init = e.init), !t.did && e.did && (t.did = `${e.did}`), typeof e.started == "number" && (t.started = e.started), t.ignoreDuration)
+    t.duration = void 0;
+  else if (typeof e.duration == "number")
+    t.duration = e.duration;
+  else {
+    const n = t.timestamp - t.started;
+    t.duration = n >= 0 ? n : 0;
+  }
+  e.release && (t.release = e.release), e.environment && (t.environment = e.environment), !t.ipAddress && e.ipAddress && (t.ipAddress = e.ipAddress), !t.userAgent && e.userAgent && (t.userAgent = e.userAgent), typeof e.errors == "number" && (t.errors = e.errors), e.status && (t.status = e.status);
+}
+function Sr(t, e) {
+  let n = {};
+  t.status === "ok" && (n = { status: "exited" }), G(t, n);
+}
+function br(t) {
+  return {
+    sid: `${t.sid}`,
+    init: t.init,
+    // Make sure that sec is converted to ms for date constructor
+    started: new Date(t.started * 1e3).toISOString(),
+    timestamp: new Date(t.timestamp * 1e3).toISOString(),
+    status: t.status,
+    errors: t.errors,
+    did: typeof t.did == "number" || typeof t.did == "string" ? `${t.did}` : void 0,
+    duration: t.duration,
+    abnormal_mechanism: t.abnormal_mechanism,
+    attrs: {
+      release: t.release,
+      environment: t.environment,
+      ip_address: t.ipAddress,
+      user_agent: t.userAgent
+    }
+  };
+}
+function Q(t, e, n = 2) {
+  if (!e || typeof e != "object" || n <= 0)
+    return e;
+  if (t && Object.keys(e).length === 0)
+    return t;
+  const r = { ...t };
+  for (const s in e)
+    Object.prototype.hasOwnProperty.call(e, s) && (r[s] = Q(r[s], e[s], n - 1));
+  return r;
+}
+function _e() {
+  return I();
+}
+function hn() {
+  return I().substring(16);
+}
+const Ct = "_sentrySpan";
+function ye(t, e) {
+  e ? F(t, Ct, e) : delete t[Ct];
+}
+function Ee(t) {
+  return t[Ct];
+}
+const Tr = 100;
+class w {
+  /** Flag if notifying is happening. */
+  /** Callback for client to receive scope changes. */
+  /** Callback list that will be called during event processing. */
+  /** Array of breadcrumbs. */
+  /** User */
+  /** Tags */
+  /** Extra */
+  /** Contexts */
+  /** Attachments */
+  /** Propagation Context for distributed tracing */
+  /**
+   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get
+   * sent to Sentry
+   */
+  /** Fingerprint */
+  /** Severity */
+  /**
+   * Transaction Name
+   *
+   * IMPORTANT: The transaction name on the scope has nothing to do with root spans/transaction objects.
+   * It's purpose is to assign a transaction to the scope that's added to non-transaction events.
+   */
+  /** Session */
+  /** The client on this scope */
+  /** Contains the last event id of a captured event.  */
+  // NOTE: Any field which gets added here should get added not only to the constructor but also to the `clone` method.
+  constructor() {
+    this._notifyingListeners = !1, this._scopeListeners = [], this._eventProcessors = [], this._breadcrumbs = [], this._attachments = [], this._user = {}, this._tags = {}, this._extra = {}, this._contexts = {}, this._sdkProcessingMetadata = {}, this._propagationContext = {
+      traceId: _e(),
+      sampleRand: Math.random()
+    };
+  }
+  /**
+   * Clone all data from this scope into a new scope.
+   */
+  clone() {
+    const e = new w();
+    return e._breadcrumbs = [...this._breadcrumbs], e._tags = { ...this._tags }, e._extra = { ...this._extra }, e._contexts = { ...this._contexts }, this._contexts.flags && (e._contexts.flags = {
+      values: [...this._contexts.flags.values]
+    }), e._user = this._user, e._level = this._level, e._session = this._session, e._transactionName = this._transactionName, e._fingerprint = this._fingerprint, e._eventProcessors = [...this._eventProcessors], e._attachments = [...this._attachments], e._sdkProcessingMetadata = { ...this._sdkProcessingMetadata }, e._propagationContext = { ...this._propagationContext }, e._client = this._client, e._lastEventId = this._lastEventId, ye(e, Ee(this)), e;
+  }
+  /**
+   * Update the client assigned to this scope.
+   * Note that not every scope will have a client assigned - isolation scopes & the global scope will generally not have a client,
+   * as well as manually created scopes.
+   */
+  setClient(e) {
+    this._client = e;
+  }
+  /**
+   * Set the ID of the last captured error event.
+   * This is generally only captured on the isolation scope.
+   */
+  setLastEventId(e) {
+    this._lastEventId = e;
+  }
+  /**
+   * Get the client assigned to this scope.
+   */
+  getClient() {
+    return this._client;
+  }
+  /**
+   * Get the ID of the last captured error event.
+   * This is generally only available on the isolation scope.
+   */
+  lastEventId() {
+    return this._lastEventId;
+  }
+  /**
+   * @inheritDoc
+   */
+  addScopeListener(e) {
+    this._scopeListeners.push(e);
+  }
+  /**
+   * Add an event processor that will be called before an event is sent.
+   */
+  addEventProcessor(e) {
+    return this._eventProcessors.push(e), this;
+  }
+  /**
+   * Set the user for this scope.
+   * Set to `null` to unset the user.
+   */
+  setUser(e) {
+    return this._user = e || {
+      email: void 0,
+      id: void 0,
+      ip_address: void 0,
+      username: void 0
+    }, this._session && G(this._session, { user: e }), this._notifyScopeListeners(), this;
+  }
+  /**
+   * Get the user from this scope.
+   */
+  getUser() {
+    return this._user;
+  }
+  /**
+   * Set an object that will be merged into existing tags on the scope,
+   * and will be sent as tags data with the event.
+   */
+  setTags(e) {
+    return this._tags = {
+      ...this._tags,
+      ...e
+    }, this._notifyScopeListeners(), this;
+  }
+  /**
+   * Set a single tag that will be sent as tags data with the event.
+   */
+  setTag(e, n) {
+    return this._tags = { ...this._tags, [e]: n }, this._notifyScopeListeners(), this;
+  }
+  /**
+   * Set an object that will be merged into existing extra on the scope,
+   * and will be sent as extra data with the event.
+   */
+  setExtras(e) {
+    return this._extra = {
+      ...this._extra,
+      ...e
+    }, this._notifyScopeListeners(), this;
+  }
+  /**
+   * Set a single key:value extra entry that will be sent as extra data with the event.
+   */
+  setExtra(e, n) {
+    return this._extra = { ...this._extra, [e]: n }, this._notifyScopeListeners(), this;
+  }
+  /**
+   * Sets the fingerprint on the scope to send with the events.
+   * @param {string[]} fingerprint Fingerprint to group events in Sentry.
+   */
+  setFingerprint(e) {
+    return this._fingerprint = e, this._notifyScopeListeners(), this;
+  }
+  /**
+   * Sets the level on the scope for future events.
+   */
+  setLevel(e) {
+    return this._level = e, this._notifyScopeListeners(), this;
+  }
+  /**
+   * Sets the transaction name on the scope so that the name of e.g. taken server route or
+   * the page location is attached to future events.
+   *
+   * IMPORTANT: Calling this function does NOT change the name of the currently active
+   * root span. If you want to change the name of the active root span, use
+   * `Sentry.updateSpanName(rootSpan, 'new name')` instead.
+   *
+   * By default, the SDK updates the scope's transaction name automatically on sensible
+   * occasions, such as a page navigation or when handling a new request on the server.
+   */
+  setTransactionName(e) {
+    return this._transactionName = e, this._notifyScopeListeners(), this;
+  }
+  /**
+   * Sets context data with the given name.
+   * Data passed as context will be normalized. You can also pass `null` to unset the context.
+   * Note that context data will not be merged - calling `setContext` will overwrite an existing context with the same key.
+   */
+  setContext(e, n) {
+    return n === null ? delete this._contexts[e] : this._contexts[e] = n, this._notifyScopeListeners(), this;
+  }
+  /**
+   * Set the session for the scope.
+   */
+  setSession(e) {
+    return e ? this._session = e : delete this._session, this._notifyScopeListeners(), this;
+  }
+  /**
+   * Get the session from the scope.
+   */
+  getSession() {
+    return this._session;
+  }
+  /**
+   * Updates the scope with provided data. Can work in three variations:
+   * - plain object containing updatable attributes
+   * - Scope instance that'll extract the attributes from
+   * - callback function that'll receive the current scope as an argument and allow for modifications
+   */
+  update(e) {
+    if (!e)
+      return this;
+    const n = typeof e == "function" ? e(this) : e, r = n instanceof w ? n.getScopeData() : K(n) ? e : void 0, { tags: s, extra: o, user: i, contexts: a, level: c, fingerprint: u = [], propagationContext: f } = r || {};
+    return this._tags = { ...this._tags, ...s }, this._extra = { ...this._extra, ...o }, this._contexts = { ...this._contexts, ...a }, i && Object.keys(i).length && (this._user = i), c && (this._level = c), u.length && (this._fingerprint = u), f && (this._propagationContext = f), this;
+  }
+  /**
+   * Clears the current scope and resets its properties.
+   * Note: The client will not be cleared.
+   */
+  clear() {
+    return this._breadcrumbs = [], this._tags = {}, this._extra = {}, this._user = {}, this._contexts = {}, this._level = void 0, this._transactionName = void 0, this._fingerprint = void 0, this._session = void 0, ye(this, void 0), this._attachments = [], this.setPropagationContext({ traceId: _e(), sampleRand: Math.random() }), this._notifyScopeListeners(), this;
+  }
+  /**
+   * Adds a breadcrumb to the scope.
+   * By default, the last 100 breadcrumbs are kept.
+   */
+  addBreadcrumb(e, n) {
+    const r = typeof n == "number" ? n : Tr;
+    if (r <= 0)
+      return this;
+    const s = {
+      timestamp: Z(),
+      ...e,
+      // Breadcrumb messages can theoretically be infinitely large and they're held in memory so we truncate them not to leak (too much) memory
+      message: e.message ? dt(e.message, 2048) : e.message
+    };
+    return this._breadcrumbs.push(s), this._breadcrumbs.length > r && (this._breadcrumbs = this._breadcrumbs.slice(-r), this._client?.recordDroppedEvent("buffer_overflow", "log_item")), this._notifyScopeListeners(), this;
+  }
+  /**
+   * Get the last breadcrumb of the scope.
+   */
+  getLastBreadcrumb() {
+    return this._breadcrumbs[this._breadcrumbs.length - 1];
+  }
+  /**
+   * Clear all breadcrumbs from the scope.
+   */
+  clearBreadcrumbs() {
+    return this._breadcrumbs = [], this._notifyScopeListeners(), this;
+  }
+  /**
+   * Add an attachment to the scope.
+   */
+  addAttachment(e) {
+    return this._attachments.push(e), this;
+  }
+  /**
+   * Clear all attachments from the scope.
+   */
+  clearAttachments() {
+    return this._attachments = [], this;
+  }
+  /**
+   * Get the data of this scope, which should be applied to an event during processing.
+   */
+  getScopeData() {
+    return {
+      breadcrumbs: this._breadcrumbs,
+      attachments: this._attachments,
+      contexts: this._contexts,
+      tags: this._tags,
+      extra: this._extra,
+      user: this._user,
+      level: this._level,
+      fingerprint: this._fingerprint || [],
+      eventProcessors: this._eventProcessors,
+      propagationContext: this._propagationContext,
+      sdkProcessingMetadata: this._sdkProcessingMetadata,
+      transactionName: this._transactionName,
+      span: Ee(this)
+    };
+  }
+  /**
+   * Add data which will be accessible during event processing but won't get sent to Sentry.
+   */
+  setSDKProcessingMetadata(e) {
+    return this._sdkProcessingMetadata = Q(this._sdkProcessingMetadata, e, 2), this;
+  }
+  /**
+   * Add propagation context to the scope, used for distributed tracing
+   */
+  setPropagationContext(e) {
+    return this._propagationContext = e, this;
+  }
+  /**
+   * Get propagation context from the scope, used for distributed tracing
+   */
+  getPropagationContext() {
+    return this._propagationContext;
+  }
+  /**
+   * Capture an exception for this scope.
+   *
+   * @returns {string} The id of the captured Sentry event.
+   */
+  captureException(e, n) {
+    const r = n?.event_id || I();
+    if (!this._client)
+      return h && p.warn("No client configured on scope - will not capture exception!"), r;
+    const s = new Error("Sentry syntheticException");
+    return this._client.captureException(
+      e,
+      {
+        originalException: e,
+        syntheticException: s,
+        ...n,
+        event_id: r
+      },
+      this
+    ), r;
+  }
+  /**
+   * Capture a message for this scope.
+   *
+   * @returns {string} The id of the captured message.
+   */
+  captureMessage(e, n, r) {
+    const s = r?.event_id || I();
+    if (!this._client)
+      return h && p.warn("No client configured on scope - will not capture message!"), s;
+    const o = new Error(e);
+    return this._client.captureMessage(
+      e,
+      n,
+      {
+        originalException: e,
+        syntheticException: o,
+        ...r,
+        event_id: s
+      },
+      this
+    ), s;
+  }
+  /**
+   * Capture a Sentry event for this scope.
+   *
+   * @returns {string} The id of the captured event.
+   */
+  captureEvent(e, n) {
+    const r = n?.event_id || I();
+    return this._client ? (this._client.captureEvent(e, { ...n, event_id: r }, this), r) : (h && p.warn("No client configured on scope - will not capture event!"), r);
+  }
+  /**
+   * This will be called on every set call.
+   */
+  _notifyScopeListeners() {
+    this._notifyingListeners || (this._notifyingListeners = !0, this._scopeListeners.forEach((e) => {
+      e(this);
+    }), this._notifyingListeners = !1);
+  }
+}
+function Ir() {
+  return J("defaultCurrentScope", () => new w());
+}
+function vr() {
+  return J("defaultIsolationScope", () => new w());
+}
+class wr {
+  constructor(e, n) {
+    let r;
+    e ? r = e : r = new w();
+    let s;
+    n ? s = n : s = new w(), this._stack = [{ scope: r }], this._isolationScope = s;
+  }
+  /**
+   * Fork a scope for the stack.
+   */
+  withScope(e) {
+    const n = this._pushScope();
+    let r;
+    try {
+      r = e(n);
+    } catch (s) {
+      throw this._popScope(), s;
+    }
+    return yt(r) ? r.then(
+      (s) => (this._popScope(), s),
+      (s) => {
+        throw this._popScope(), s;
+      }
+    ) : (this._popScope(), r);
+  }
+  /**
+   * Get the client of the stack.
+   */
+  getClient() {
+    return this.getStackTop().client;
+  }
+  /**
+   * Returns the scope of the top stack.
+   */
+  getScope() {
+    return this.getStackTop().scope;
+  }
+  /**
+   * Get the isolation scope for the stack.
+   */
+  getIsolationScope() {
+    return this._isolationScope;
+  }
+  /**
+   * Returns the topmost scope layer in the order domain > local > process.
+   */
+  getStackTop() {
+    return this._stack[this._stack.length - 1];
+  }
+  /**
+   * Push a scope to the stack.
+   */
+  _pushScope() {
+    const e = this.getScope().clone();
+    return this._stack.push({
+      client: this.getClient(),
+      scope: e
+    }), e;
+  }
+  /**
+   * Pop a scope from the stack.
+   */
+  _popScope() {
+    return this._stack.length <= 1 ? !1 : !!this._stack.pop();
+  }
+}
+function W() {
+  const t = mt(), e = gt(t);
+  return e.stack = e.stack || new wr(Ir(), vr());
+}
+function Rr(t) {
+  return W().withScope(t);
+}
+function kr(t, e) {
+  const n = W();
+  return n.withScope(() => (n.getStackTop().scope = t, e(t)));
+}
+function Se(t) {
+  return W().withScope(() => t(W().getIsolationScope()));
+}
+function Ar() {
+  return {
+    withIsolationScope: Se,
+    withScope: Rr,
+    withSetScope: kr,
+    withSetIsolationScope: (t, e) => Se(e),
+    getCurrentScope: () => W().getScope(),
+    getIsolationScope: () => W().getIsolationScope()
+  };
+}
+function Qt(t) {
+  const e = gt(t);
+  return e.acs ? e.acs : Ar();
+}
+function D() {
+  const t = mt();
+  return Qt(t).getCurrentScope();
+}
+function tt() {
+  const t = mt();
+  return Qt(t).getIsolationScope();
+}
+function xr() {
+  return J("globalScope", () => new w());
+}
+function Or(...t) {
+  const e = mt(), n = Qt(e);
+  if (t.length === 2) {
+    const [r, s] = t;
+    return r ? n.withSetScope(r, s) : n.withScope(s);
+  }
+  return n.withScope(t[0]);
+}
+function b() {
+  return D().getClient();
+}
+function Nr(t) {
+  const e = t.getPropagationContext(), { traceId: n, parentSpanId: r, propagationSpanId: s } = e, o = {
+    trace_id: n,
+    span_id: s || hn()
+  };
+  return r && (o.parent_span_id = r), o;
+}
+const Cr = "sentry.source", Dr = "sentry.sample_rate", Lr = "sentry.previous_trace_sample_rate", Pr = "sentry.op", Mr = "sentry.origin", mn = "sentry.profile_id", gn = "sentry.exclusive_time", Fr = 0, $r = 1, Ur = "_sentryScope", jr = "_sentryIsolationScope";
+function _n(t) {
+  return {
+    scope: t[Ur],
+    isolationScope: t[jr]
+  };
+}
+const Br = "sentry-", Hr = /^sentry-/;
+function Gr(t) {
+  const e = Wr(t);
+  if (!e)
+    return;
+  const n = Object.entries(e).reduce((r, [s, o]) => {
+    if (s.match(Hr)) {
+      const i = s.slice(Br.length);
+      r[i] = o;
+    }
+    return r;
+  }, {});
+  if (Object.keys(n).length > 0)
+    return n;
+}
+function Wr(t) {
+  if (!(!t || !A(t) && !Array.isArray(t)))
+    return Array.isArray(t) ? t.reduce((e, n) => {
+      const r = be(n);
+      return Object.entries(r).forEach(([s, o]) => {
+        e[s] = o;
+      }), e;
+    }, {}) : be(t);
+}
+function be(t) {
+  return t.split(",").map(
+    (e) => e.split("=").map((n) => {
+      try {
+        return decodeURIComponent(n.trim());
+      } catch {
+        return;
+      }
+    })
+  ).reduce((e, [n, r]) => (n && r && (e[n] = r), e), {});
+}
+function qr(t) {
+  if (typeof t == "boolean")
+    return Number(t);
+  const e = typeof t == "string" ? parseFloat(t) : t;
+  if (!(typeof e != "number" || isNaN(e) || e < 0 || e > 1))
+    return e;
+}
+const yn = 1;
+let Te = !1;
+function Yr(t) {
+  const { spanId: e, traceId: n, isRemote: r } = t.spanContext(), s = r ? e : te(t).parent_span_id, o = _n(t).scope, i = r ? o?.getPropagationContext().propagationSpanId || hn() : e;
+  return {
+    parent_span_id: s,
+    span_id: i,
+    trace_id: n
+  };
+}
+function zr(t) {
+  if (t && t.length > 0)
+    return t.map(({ context: { spanId: e, traceId: n, traceFlags: r, ...s }, attributes: o }) => ({
+      span_id: e,
+      trace_id: n,
+      sampled: r === yn,
+      attributes: o,
+      ...s
+    }));
+}
+function Ie(t) {
+  return typeof t == "number" ? ve(t) : Array.isArray(t) ? t[0] + t[1] / 1e9 : t instanceof Date ? ve(t.getTime()) : x();
+}
+function ve(t) {
+  return t > 9999999999 ? t / 1e3 : t;
+}
+function te(t) {
+  if (Kr(t))
+    return t.getSpanJSON();
+  const { spanId: e, traceId: n } = t.spanContext();
+  if (Xr(t)) {
+    const { attributes: r, startTime: s, name: o, endTime: i, status: a, links: c } = t, u = "parentSpanId" in t ? t.parentSpanId : "parentSpanContext" in t ? t.parentSpanContext?.spanId : void 0;
+    return {
+      span_id: e,
+      trace_id: n,
+      data: r,
+      description: o,
+      parent_span_id: u,
+      start_timestamp: Ie(s),
+      // This is [0,0] by default in OTEL, in which case we want to interpret this as no end time
+      timestamp: Ie(i) || void 0,
+      status: Jr(a),
+      op: r[Pr],
+      origin: r[Mr],
+      links: zr(c)
+    };
+  }
+  return {
+    span_id: e,
+    trace_id: n,
+    start_timestamp: 0,
+    data: {}
+  };
+}
+function Xr(t) {
+  const e = t;
+  return !!e.attributes && !!e.startTime && !!e.name && !!e.endTime && !!e.status;
+}
+function Kr(t) {
+  return typeof t.getSpanJSON == "function";
+}
+function Vr(t) {
+  const { traceFlags: e } = t.spanContext();
+  return e === yn;
+}
+function Jr(t) {
+  if (!(!t || t.code === Fr))
+    return t.code === $r ? "ok" : t.message || "unknown_error";
+}
+const Zr = "_sentryRootSpan";
+function En(t) {
+  return t[Zr] || t;
+}
+function we() {
+  Te || (Y(() => {
+    console.warn(
+      "[Sentry] Returning null from `beforeSendSpan` is disallowed. To drop certain spans, configure the respective integrations directly."
+    );
+  }), Te = !0);
+}
+function Qr(t) {
+  if (typeof __SENTRY_TRACING__ == "boolean" && !__SENTRY_TRACING__)
+    return !1;
+  const e = t || b()?.getOptions();
+  return !!e && // Note: This check is `!= null`, meaning "nullish". `0` is not "nullish", `undefined` and `null` are. (This comment was brought to you by 15 minutes of questioning life)
+  (e.tracesSampleRate != null || !!e.tracesSampler);
+}
+const ee = "production", ts = /^o(\d+)\./, es = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+)?)?@)([\w.-]+)(?::(\d+))?\/(.+)/;
+function ns(t) {
+  return t === "http" || t === "https";
+}
+function St(t, e = !1) {
+  const { host: n, path: r, pass: s, port: o, projectId: i, protocol: a, publicKey: c } = t;
+  return `${a}://${c}${e && s ? `:${s}` : ""}@${n}${o ? `:${o}` : ""}/${r && `${r}/`}${i}`;
+}
+function rs(t) {
+  const e = es.exec(t);
+  if (!e) {
+    Y(() => {
+      console.error(`Invalid Sentry Dsn: ${t}`);
+    });
+    return;
+  }
+  const [n, r, s = "", o = "", i = "", a = ""] = e.slice(1);
+  let c = "", u = a;
+  const f = u.split("/");
+  if (f.length > 1 && (c = f.slice(0, -1).join("/"), u = f.pop()), u) {
+    const l = u.match(/^\d+/);
+    l && (u = l[0]);
+  }
+  return Sn({ host: o, pass: s, path: c, projectId: u, port: i, protocol: n, publicKey: r });
+}
+function Sn(t) {
+  return {
+    protocol: t.protocol,
+    publicKey: t.publicKey || "",
+    pass: t.pass || "",
+    host: t.host,
+    port: t.port || "",
+    path: t.path || "",
+    projectId: t.projectId
+  };
+}
+function ss(t) {
+  if (!h)
+    return !0;
+  const { port: e, projectId: n, protocol: r } = t;
+  return ["protocol", "publicKey", "host", "projectId"].find((i) => t[i] ? !1 : (p.error(`Invalid Sentry Dsn: ${i} missing`), !0)) ? !1 : n.match(/^\d+$/) ? ns(r) ? e && isNaN(parseInt(e, 10)) ? (p.error(`Invalid Sentry Dsn: Invalid port ${e}`), !1) : !0 : (p.error(`Invalid Sentry Dsn: Invalid protocol ${r}`), !1) : (p.error(`Invalid Sentry Dsn: Invalid projectId ${n}`), !1);
+}
+function os(t) {
+  return t.match(ts)?.[1];
+}
+function is(t) {
+  const e = typeof t == "string" ? rs(t) : Sn(t);
+  if (!(!e || !ss(e)))
+    return e;
+}
+const as = "_frozenDsc";
+function bn(t, e) {
+  const n = e.getOptions(), { publicKey: r, host: s } = e.getDsn() || {};
+  let o;
+  n.orgId ? o = String(n.orgId) : s && (o = os(s));
+  const i = {
+    environment: n.environment || ee,
+    release: n.release,
+    public_key: r,
+    trace_id: t,
+    org_id: o
+  };
+  return e.emit("createDsc", i), i;
+}
+function cs(t, e) {
+  const n = e.getPropagationContext();
+  return n.dsc || bn(n.traceId, t);
+}
+function us(t) {
+  const e = b();
+  if (!e)
+    return {};
+  const n = En(t), r = te(n), s = r.data, o = n.spanContext().traceState, i = o?.get("sentry.sample_rate") ?? s[Dr] ?? s[Lr];
+  function a(E) {
+    return (typeof i == "number" || typeof i == "string") && (E.sample_rate = `${i}`), E;
+  }
+  const c = n[as];
+  if (c)
+    return a(c);
+  const u = o?.get("sentry.dsc"), f = u && Gr(u);
+  if (f)
+    return a(f);
+  const l = bn(t.spanContext().traceId, e), m = s[Cr], d = r.description;
+  return m !== "url" && d && (l.transaction = d), Qr() && (l.sampled = String(Vr(n)), l.sample_rand = // In OTEL we store the sample rand on the trace state because we cannot access scopes for NonRecordingSpans
+  // The Sentry OTEL SpanSampler takes care of writing the sample rand on the root span
+  o?.get("sentry.sample_rand") ?? // On all other platforms we can actually get the scopes from a root span (we use this as a fallback)
+  _n(n).scope?.getPropagationContext().sampleRand.toString()), a(l), e.emit("createDsc", l, n), l;
+}
+function k(t, e = 100, n = 1 / 0) {
+  try {
+    return Dt("", t, e, n);
+  } catch (r) {
+    return { ERROR: `**non-serializable** (${r})` };
+  }
+}
+function Tn(t, e = 3, n = 100 * 1024) {
+  const r = k(t, e);
+  return ps(r) > n ? Tn(t, e - 1, n) : r;
+}
+function Dt(t, e, n = 1 / 0, r = 1 / 0, s = hs()) {
+  const [o, i] = s;
+  if (e == null || // this matches null and undefined -> eqeq not eqeqeq
+  ["boolean", "string"].includes(typeof e) || typeof e == "number" && Number.isFinite(e))
+    return e;
+  const a = fs(t, e);
+  if (!a.startsWith("[object "))
+    return a;
+  if (e.__sentry_skip_normalization__)
+    return e;
+  const c = typeof e.__sentry_override_normalization_depth__ == "number" ? e.__sentry_override_normalization_depth__ : n;
+  if (c === 0)
+    return a.replace("object ", "");
+  if (o(e))
+    return "[Circular ~]";
+  const u = e;
+  if (u && typeof u.toJSON == "function")
+    try {
+      const d = u.toJSON();
+      return Dt("", d, c - 1, r, s);
+    } catch {
+    }
+  const f = Array.isArray(e) ? [] : {};
+  let l = 0;
+  const m = ln(e);
+  for (const d in m) {
+    if (!Object.prototype.hasOwnProperty.call(m, d))
+      continue;
+    if (l >= r) {
+      f[d] = "[MaxProperties ~]";
+      break;
+    }
+    const E = m[d];
+    f[d] = Dt(d, E, c - 1, r, s), l++;
+  }
+  return i(e), f;
+}
+function fs(t, e) {
+  try {
+    if (t === "domain" && e && typeof e == "object" && e._events)
+      return "[Domain]";
+    if (t === "domainEmitter")
+      return "[DomainEmitter]";
+    if (typeof global < "u" && e === global)
+      return "[Global]";
+    if (typeof window < "u" && e === window)
+      return "[Window]";
+    if (typeof document < "u" && e === document)
+      return "[Document]";
+    if (cn(e))
+      return "[VueViewModel]";
+    if (ur(e))
+      return "[SyntheticEvent]";
+    if (typeof e == "number" && !Number.isFinite(e))
+      return `[${e}]`;
+    if (typeof e == "function")
+      return `[Function: ${O(e)}]`;
+    if (typeof e == "symbol")
+      return `[${String(e)}]`;
+    if (typeof e == "bigint")
+      return `[BigInt: ${String(e)}]`;
+    const n = ls(e);
+    return /^HTML(\w*)Element$/.test(n) ? `[HTMLElement: ${n}]` : `[object ${n}]`;
+  } catch (n) {
+    return `**non-serializable** (${n})`;
+  }
+}
+function ls(t) {
+  const e = Object.getPrototypeOf(t);
+  return e?.constructor ? e.constructor.name : "null prototype";
+}
+function ds(t) {
+  return ~-encodeURI(t).split(/%..|./).length;
+}
+function ps(t) {
+  return ds(JSON.stringify(t));
+}
+function hs() {
+  const t = /* @__PURE__ */ new WeakSet();
+  function e(r) {
+    return t.has(r) ? !0 : (t.add(r), !1);
+  }
+  function n(r) {
+    t.delete(r);
+  }
+  return [e, n];
+}
+function et(t, e = []) {
+  return [t, e];
+}
+function ms(t, e) {
+  const [n, r] = t;
+  return [n, [...r, e]];
+}
+function Re(t, e) {
+  const n = t[1];
+  for (const r of n) {
+    const s = r[0].type;
+    if (e(r, s))
+      return !0;
+  }
+  return !1;
+}
+function Lt(t) {
+  const e = gt(_);
+  return e.encodePolyfill ? e.encodePolyfill(t) : new TextEncoder().encode(t);
+}
+function gs(t) {
+  const [e, n] = t;
+  let r = JSON.stringify(e);
+  function s(o) {
+    typeof r == "string" ? r = typeof o == "string" ? r + o : [Lt(r), o] : r.push(typeof o == "string" ? Lt(o) : o);
+  }
+  for (const o of n) {
+    const [i, a] = o;
+    if (s(`
+${JSON.stringify(i)}
+`), typeof a == "string" || a instanceof Uint8Array)
+      s(a);
+    else {
+      let c;
+      try {
+        c = JSON.stringify(a);
+      } catch {
+        c = JSON.stringify(k(a));
+      }
+      s(c);
+    }
+  }
+  return typeof r == "string" ? r : _s(r);
+}
+function _s(t) {
+  const e = t.reduce((s, o) => s + o.length, 0), n = new Uint8Array(e);
+  let r = 0;
+  for (const s of t)
+    n.set(s, r), r += s.length;
+  return n;
+}
+function ys(t) {
+  const e = typeof t.data == "string" ? Lt(t.data) : t.data;
+  return [
+    {
+      type: "attachment",
+      length: e.length,
+      filename: t.filename,
+      content_type: t.contentType,
+      attachment_type: t.attachmentType
+    },
+    e
+  ];
+}
+const Es = {
+  session: "session",
+  sessions: "session",
+  attachment: "attachment",
+  transaction: "transaction",
+  event: "error",
+  client_report: "internal",
+  user_report: "default",
+  profile: "profile",
+  profile_chunk: "profile",
+  replay_event: "replay",
+  replay_recording: "replay",
+  check_in: "monitor",
+  feedback: "feedback",
+  span: "span",
+  raw_security: "security",
+  log: "log_item"
+};
+function ke(t) {
+  return Es[t];
+}
+function In(t) {
+  if (!t?.sdk)
+    return;
+  const { name: e, version: n } = t.sdk;
+  return { name: e, version: n };
+}
+function Ss(t, e, n, r) {
+  const s = t.sdkProcessingMetadata?.dynamicSamplingContext;
+  return {
+    event_id: t.event_id,
+    sent_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...e && { sdk: e },
+    ...!!n && r && { dsn: St(r) },
+    ...s && {
+      trace: s
+    }
+  };
+}
+function bs(t, e) {
+  return e && (t.sdk = t.sdk || {}, t.sdk.name = t.sdk.name || e.name, t.sdk.version = t.sdk.version || e.version, t.sdk.integrations = [...t.sdk.integrations || [], ...e.integrations || []], t.sdk.packages = [...t.sdk.packages || [], ...e.packages || []]), t;
+}
+function Ts(t, e, n, r) {
+  const s = In(n), o = {
+    sent_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...s && { sdk: s },
+    ...!!r && e && { dsn: St(e) }
+  }, i = "aggregates" in t ? [{ type: "sessions" }, t] : [{ type: "session" }, t.toJSON()];
+  return et(o, [i]);
+}
+function Is(t, e, n, r) {
+  const s = In(n), o = t.type && t.type !== "replay_event" ? t.type : "event";
+  bs(t, n?.sdk);
+  const i = Ss(t, s, r, e);
+  return delete t.sdkProcessingMetadata, et(i, [[{ type: o }, t]]);
+}
+const Rt = 0, Ae = 1, xe = 2;
+function $(t) {
+  return new C((e) => {
+    e(t);
+  });
+}
+function pt(t) {
+  return new C((e, n) => {
+    n(t);
+  });
+}
+class C {
+  constructor(e) {
+    this._state = Rt, this._handlers = [], this._runExecutor(e);
+  }
+  /** @inheritdoc */
+  then(e, n) {
+    return new C((r, s) => {
+      this._handlers.push([
+        !1,
+        (o) => {
+          if (!e)
+            r(o);
+          else
+            try {
+              r(e(o));
+            } catch (i) {
+              s(i);
+            }
+        },
+        (o) => {
+          if (!n)
+            s(o);
+          else
+            try {
+              r(n(o));
+            } catch (i) {
+              s(i);
+            }
+        }
+      ]), this._executeHandlers();
+    });
+  }
+  /** @inheritdoc */
+  catch(e) {
+    return this.then((n) => n, e);
+  }
+  /** @inheritdoc */
+  finally(e) {
+    return new C((n, r) => {
+      let s, o;
+      return this.then(
+        (i) => {
+          o = !1, s = i, e && e();
+        },
+        (i) => {
+          o = !0, s = i, e && e();
+        }
+      ).then(() => {
+        if (o) {
+          r(s);
+          return;
+        }
+        n(s);
+      });
+    });
+  }
+  /** Excute the resolve/reject handlers. */
+  _executeHandlers() {
+    if (this._state === Rt)
+      return;
+    const e = this._handlers.slice();
+    this._handlers = [], e.forEach((n) => {
+      n[0] || (this._state === Ae && n[1](this._value), this._state === xe && n[2](this._value), n[0] = !0);
+    });
+  }
+  /** Run the executor for the SyncPromise. */
+  _runExecutor(e) {
+    const n = (o, i) => {
+      if (this._state === Rt) {
+        if (yt(i)) {
+          i.then(r, s);
+          return;
+        }
+        this._state = o, this._value = i, this._executeHandlers();
+      }
+    }, r = (o) => {
+      n(Ae, o);
+    }, s = (o) => {
+      n(xe, o);
+    };
+    try {
+      e(r, s);
+    } catch (o) {
+      s(o);
+    }
+  }
+}
+function Pt(t, e, n, r = 0) {
+  return new C((s, o) => {
+    const i = t[r];
+    if (e === null || typeof i != "function")
+      s(e);
+    else {
+      const a = i({ ...e }, n);
+      h && i.id && a === null && p.log(`Event processor "${i.id}" dropped event`), yt(a) ? a.then((c) => Pt(t, c, n, r + 1).then(s)).then(null, o) : Pt(t, a, n, r + 1).then(s).then(null, o);
+    }
+  });
+}
+function vs(t, e) {
+  const { fingerprint: n, span: r, breadcrumbs: s, sdkProcessingMetadata: o } = e;
+  ws(t, e), r && As(t, r), xs(t, n), Rs(t, s), ks(t, o);
+}
+function Oe(t, e) {
+  const {
+    extra: n,
+    tags: r,
+    user: s,
+    contexts: o,
+    level: i,
+    sdkProcessingMetadata: a,
+    breadcrumbs: c,
+    fingerprint: u,
+    eventProcessors: f,
+    attachments: l,
+    propagationContext: m,
+    transactionName: d,
+    span: E
+  } = e;
+  rt(t, "extra", n), rt(t, "tags", r), rt(t, "user", s), rt(t, "contexts", o), t.sdkProcessingMetadata = Q(t.sdkProcessingMetadata, a, 2), i && (t.level = i), d && (t.transactionName = d), E && (t.span = E), c.length && (t.breadcrumbs = [...t.breadcrumbs, ...c]), u.length && (t.fingerprint = [...t.fingerprint, ...u]), f.length && (t.eventProcessors = [...t.eventProcessors, ...f]), l.length && (t.attachments = [...t.attachments, ...l]), t.propagationContext = { ...t.propagationContext, ...m };
+}
+function rt(t, e, n) {
+  t[e] = Q(t[e], n, 1);
+}
+function ws(t, e) {
+  const { extra: n, tags: r, user: s, contexts: o, level: i, transactionName: a } = e;
+  Object.keys(n).length && (t.extra = { ...n, ...t.extra }), Object.keys(r).length && (t.tags = { ...r, ...t.tags }), Object.keys(s).length && (t.user = { ...s, ...t.user }), Object.keys(o).length && (t.contexts = { ...o, ...t.contexts }), i && (t.level = i), a && t.type !== "transaction" && (t.transaction = a);
+}
+function Rs(t, e) {
+  const n = [...t.breadcrumbs || [], ...e];
+  t.breadcrumbs = n.length ? n : void 0;
+}
+function ks(t, e) {
+  t.sdkProcessingMetadata = {
+    ...t.sdkProcessingMetadata,
+    ...e
+  };
+}
+function As(t, e) {
+  t.contexts = {
+    trace: Yr(e),
+    ...t.contexts
+  }, t.sdkProcessingMetadata = {
+    dynamicSamplingContext: us(e),
+    ...t.sdkProcessingMetadata
+  };
+  const n = En(e), r = te(n).description;
+  r && !t.transaction && t.type === "transaction" && (t.transaction = r);
+}
+function xs(t, e) {
+  t.fingerprint = t.fingerprint ? Array.isArray(t.fingerprint) ? t.fingerprint : [t.fingerprint] : [], e && (t.fingerprint = t.fingerprint.concat(e)), t.fingerprint.length || delete t.fingerprint;
+}
+let st, Ne, ot;
+function Os(t) {
+  const e = _._sentryDebugIds;
+  if (!e)
+    return {};
+  const n = Object.keys(e);
+  return ot && n.length === Ne || (Ne = n.length, ot = n.reduce((r, s) => {
+    st || (st = {});
+    const o = st[s];
+    if (o)
+      r[o[0]] = o[1];
+    else {
+      const i = t(s);
+      for (let a = i.length - 1; a >= 0; a--) {
+        const u = i[a]?.filename, f = e[s];
+        if (u && f) {
+          r[u] = f, st[s] = [u, f];
+          break;
+        }
+      }
+    }
+    return r;
+  }, {})), ot;
+}
+function Ns(t, e, n, r, s, o) {
+  const { normalizeDepth: i = 3, normalizeMaxBreadth: a = 1e3 } = t, c = {
+    ...e,
+    event_id: e.event_id || n.event_id || I(),
+    timestamp: e.timestamp || Z()
+  }, u = n.integrations || t.integrations.map((g) => g.name);
+  Cs(c, t), Ps(c, u), s && s.emit("applyFrameMetadata", e), e.type === void 0 && Ds(c, t.stackParser);
+  const f = Fs(r, n.captureContext);
+  n.mechanism && H(c, n.mechanism);
+  const l = s ? s.getEventProcessors() : [], m = xr().getScopeData();
+  if (o) {
+    const g = o.getScopeData();
+    Oe(m, g);
+  }
+  if (f) {
+    const g = f.getScopeData();
+    Oe(m, g);
+  }
+  const d = [...n.attachments || [], ...m.attachments];
+  d.length && (n.attachments = d), vs(c, m);
+  const E = [
+    ...l,
+    // Run scope event processors _after_ all other processors
+    ...m.eventProcessors
+  ];
+  return Pt(E, c, n).then((g) => (g && Ls(g), typeof i == "number" && i > 0 ? Ms(g, i, a) : g));
+}
+function Cs(t, e) {
+  const { environment: n, release: r, dist: s, maxValueLength: o = 250 } = e;
+  t.environment = t.environment || n || ee, !t.release && r && (t.release = r), !t.dist && s && (t.dist = s);
+  const i = t.request;
+  i?.url && (i.url = dt(i.url, o));
+}
+function Ds(t, e) {
+  const n = Os(e);
+  t.exception?.values?.forEach((r) => {
+    r.stacktrace?.frames?.forEach((s) => {
+      s.filename && (s.debug_id = n[s.filename]);
+    });
+  });
+}
+function Ls(t) {
+  const e = {};
+  if (t.exception?.values?.forEach((r) => {
+    r.stacktrace?.frames?.forEach((s) => {
+      s.debug_id && (s.abs_path ? e[s.abs_path] = s.debug_id : s.filename && (e[s.filename] = s.debug_id), delete s.debug_id);
+    });
+  }), Object.keys(e).length === 0)
+    return;
+  t.debug_meta = t.debug_meta || {}, t.debug_meta.images = t.debug_meta.images || [];
+  const n = t.debug_meta.images;
+  Object.entries(e).forEach(([r, s]) => {
+    n.push({
+      type: "sourcemap",
+      code_file: r,
+      debug_id: s
+    });
+  });
+}
+function Ps(t, e) {
+  e.length > 0 && (t.sdk = t.sdk || {}, t.sdk.integrations = [...t.sdk.integrations || [], ...e]);
+}
+function Ms(t, e, n) {
+  if (!t)
+    return null;
+  const r = {
+    ...t,
+    ...t.breadcrumbs && {
+      breadcrumbs: t.breadcrumbs.map((s) => ({
+        ...s,
+        ...s.data && {
+          data: k(s.data, e, n)
+        }
+      }))
+    },
+    ...t.user && {
+      user: k(t.user, e, n)
+    },
+    ...t.contexts && {
+      contexts: k(t.contexts, e, n)
+    },
+    ...t.extra && {
+      extra: k(t.extra, e, n)
+    }
+  };
+  return t.contexts?.trace && r.contexts && (r.contexts.trace = t.contexts.trace, t.contexts.trace.data && (r.contexts.trace.data = k(t.contexts.trace.data, e, n))), t.spans && (r.spans = t.spans.map((s) => ({
+    ...s,
+    ...s.data && {
+      data: k(s.data, e, n)
+    }
+  }))), t.contexts?.flags && r.contexts && (r.contexts.flags = k(t.contexts.flags, 3, n)), r;
+}
+function Fs(t, e) {
+  if (!e)
+    return t;
+  const n = t ? t.clone() : new w();
+  return n.update(e), n;
+}
+function $s(t) {
+  if (t)
+    return Us(t) ? { captureContext: t } : Bs(t) ? {
+      captureContext: t
+    } : t;
+}
+function Us(t) {
+  return t instanceof w || typeof t == "function";
+}
+const js = [
+  "user",
+  "level",
+  "extra",
+  "contexts",
+  "tags",
+  "fingerprint",
+  "propagationContext"
+];
+function Bs(t) {
+  return Object.keys(t).some((e) => js.includes(e));
+}
+function vn(t, e) {
+  return D().captureException(t, $s(e));
+}
+function wn(t, e) {
+  return D().captureEvent(t, e);
+}
+function Ce(t) {
+  const e = tt(), n = D(), { userAgent: r } = _.navigator || {}, s = Er({
+    user: n.getUser() || e.getUser(),
+    ...r && { userAgent: r },
+    ...t
+  }), o = e.getSession();
+  return o?.status === "ok" && G(o, { status: "exited" }), Rn(), e.setSession(s), s;
+}
+function Rn() {
+  const t = tt(), n = D().getSession() || t.getSession();
+  n && Sr(n), kn(), t.setSession();
+}
+function kn() {
+  const t = tt(), e = b(), n = t.getSession();
+  n && e && e.captureSession(n);
+}
+function De(t = !1) {
+  if (t) {
+    Rn();
+    return;
+  }
+  kn();
+}
+const Hs = "7";
+function Gs(t) {
+  const e = t.protocol ? `${t.protocol}:` : "", n = t.port ? `:${t.port}` : "";
+  return `${e}//${t.host}${n}${t.path ? `/${t.path}` : ""}/api/`;
+}
+function Ws(t) {
+  return `${Gs(t)}${t.projectId}/envelope/`;
+}
+function qs(t, e) {
+  const n = {
+    sentry_version: Hs
+  };
+  return t.publicKey && (n.sentry_key = t.publicKey), e && (n.sentry_client = `${e.name}/${e.version}`), new URLSearchParams(n).toString();
+}
+function Ys(t, e, n) {
+  return e || `${Ws(t)}?${qs(t, n)}`;
+}
+const Le = [];
+function zs(t) {
+  const e = {};
+  return t.forEach((n) => {
+    const { name: r } = n, s = e[r];
+    s && !s.isDefaultInstance && n.isDefaultInstance || (e[r] = n);
+  }), Object.values(e);
+}
+function Xs(t) {
+  const e = t.defaultIntegrations || [], n = t.integrations;
+  e.forEach((s) => {
+    s.isDefaultInstance = !0;
+  });
+  let r;
+  if (Array.isArray(n))
+    r = [...e, ...n];
+  else if (typeof n == "function") {
+    const s = n(e);
+    r = Array.isArray(s) ? s : [s];
+  } else
+    r = e;
+  return zs(r);
+}
+function Ks(t, e) {
+  const n = {};
+  return e.forEach((r) => {
+    r && An(t, r, n);
+  }), n;
+}
+function Pe(t, e) {
+  for (const n of e)
+    n?.afterAllSetup && n.afterAllSetup(t);
+}
+function An(t, e, n) {
+  if (n[e.name]) {
+    h && p.log(`Integration skipped because it was already installed: ${e.name}`);
+    return;
+  }
+  if (n[e.name] = e, Le.indexOf(e.name) === -1 && typeof e.setupOnce == "function" && (e.setupOnce(), Le.push(e.name)), e.setup && typeof e.setup == "function" && e.setup(t), typeof e.preprocessEvent == "function") {
+    const r = e.preprocessEvent.bind(e);
+    t.on("preprocessEvent", (s, o) => r(s, o, t));
+  }
+  if (typeof e.processEvent == "function") {
+    const r = e.processEvent.bind(e), s = Object.assign((o, i) => r(o, i, t), {
+      id: e.name
+    });
+    t.addEventProcessor(s);
+  }
+  h && p.log(`Integration installed: ${e.name}`);
+}
+function Vs(t, e, n) {
+  const r = [
+    { type: "client_report" },
+    {
+      timestamp: Z(),
+      discarded_events: t
+    }
+  ];
+  return et(e ? { dsn: e } : {}, [r]);
+}
+function xn(t) {
+  const e = [];
+  t.message && e.push(t.message);
+  try {
+    const n = t.exception.values[t.exception.values.length - 1];
+    n?.value && (e.push(n.value), n.type && e.push(`${n.type}: ${n.value}`));
+  } catch {
+  }
+  return e;
+}
+function Js(t) {
+  const { trace_id: e, parent_span_id: n, span_id: r, status: s, origin: o, data: i, op: a } = t.contexts?.trace ?? {};
+  return {
+    data: i ?? {},
+    description: t.transaction,
+    op: a,
+    parent_span_id: n,
+    span_id: r ?? "",
+    start_timestamp: t.start_timestamp ?? 0,
+    status: s,
+    timestamp: t.timestamp,
+    trace_id: e ?? "",
+    origin: o,
+    profile_id: i?.[mn],
+    exclusive_time: i?.[gn],
+    measurements: t.measurements,
+    is_segment: !0
+  };
+}
+function Zs(t) {
+  return {
+    type: "transaction",
+    timestamp: t.timestamp,
+    start_timestamp: t.start_timestamp,
+    transaction: t.description,
+    contexts: {
+      trace: {
+        trace_id: t.trace_id,
+        span_id: t.span_id,
+        parent_span_id: t.parent_span_id,
+        op: t.op,
+        status: t.status,
+        origin: t.origin,
+        data: {
+          ...t.data,
+          ...t.profile_id && { [mn]: t.profile_id },
+          ...t.exclusive_time && { [gn]: t.exclusive_time }
+        }
+      }
+    },
+    measurements: t.measurements
+  };
+}
+const Me = "Not capturing exception because it's already been captured.", Fe = "Discarded session because of missing or non-string release", On = Symbol.for("SentryInternalError"), Nn = Symbol.for("SentryDoNotSendEventError");
+function ut(t) {
+  return {
+    message: t,
+    [On]: !0
+  };
+}
+function kt(t) {
+  return {
+    message: t,
+    [Nn]: !0
+  };
+}
+function $e(t) {
+  return !!t && typeof t == "object" && On in t;
+}
+function Ue(t) {
+  return !!t && typeof t == "object" && Nn in t;
+}
+class Qs {
+  /** Options passed to the SDK. */
+  /** The client Dsn, if specified in options. Without this Dsn, the SDK will be disabled. */
+  /** Array of set up integrations. */
+  /** Number of calls being processed */
+  /** Holds flushable  */
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  /**
+   * Initializes this client instance.
+   *
+   * @param options Options for the client.
+   */
+  constructor(e) {
+    if (this._options = e, this._integrations = {}, this._numProcessing = 0, this._outcomes = {}, this._hooks = {}, this._eventProcessors = [], e.dsn ? this._dsn = is(e.dsn) : h && p.warn("No DSN provided, client will not send events."), this._dsn) {
+      const n = Ys(
+        this._dsn,
+        e.tunnel,
+        e._metadata ? e._metadata.sdk : void 0
+      );
+      this._transport = e.transport({
+        tunnel: this._options.tunnel,
+        recordDroppedEvent: this.recordDroppedEvent.bind(this),
+        ...e.transportOptions,
+        url: n
+      });
+    }
+  }
+  /**
+   * Captures an exception event and sends it to Sentry.
+   *
+   * Unlike `captureException` exported from every SDK, this method requires that you pass it the current scope.
+   */
+  captureException(e, n, r) {
+    const s = I();
+    if (me(e))
+      return h && p.log(Me), s;
+    const o = {
+      event_id: s,
+      ...n
+    };
+    return this._process(
+      this.eventFromException(e, o).then(
+        (i) => this._captureEvent(i, o, r)
+      )
+    ), o.event_id;
+  }
+  /**
+   * Captures a message event and sends it to Sentry.
+   *
+   * Unlike `captureMessage` exported from every SDK, this method requires that you pass it the current scope.
+   */
+  captureMessage(e, n, r, s) {
+    const o = {
+      event_id: I(),
+      ...r
+    }, i = Xt(e) ? e : String(e), a = Kt(e) ? this.eventFromMessage(i, n, o) : this.eventFromException(e, o);
+    return this._process(a.then((c) => this._captureEvent(c, o, s))), o.event_id;
+  }
+  /**
+   * Captures a manually created event and sends it to Sentry.
+   *
+   * Unlike `captureEvent` exported from every SDK, this method requires that you pass it the current scope.
+   */
+  captureEvent(e, n, r) {
+    const s = I();
+    if (n?.originalException && me(n.originalException))
+      return h && p.log(Me), s;
+    const o = {
+      event_id: s,
+      ...n
+    }, i = e.sdkProcessingMetadata || {}, a = i.capturedSpanScope, c = i.capturedSpanIsolationScope;
+    return this._process(
+      this._captureEvent(e, o, a || r, c)
+    ), o.event_id;
+  }
+  /**
+   * Captures a session.
+   */
+  captureSession(e) {
+    this.sendSession(e), G(e, { init: !1 });
+  }
+  /**
+   * Create a cron monitor check in and send it to Sentry. This method is not available on all clients.
+   *
+   * @param checkIn An object that describes a check in.
+   * @param upsertMonitorConfig An optional object that describes a monitor config. Use this if you want
+   * to create a monitor automatically when sending a check in.
+   * @param scope An optional scope containing event metadata.
+   * @returns A string representing the id of the check in.
+   */
+  /**
+   * Get the current Dsn.
+   */
+  getDsn() {
+    return this._dsn;
+  }
+  /**
+   * Get the current options.
+   */
+  getOptions() {
+    return this._options;
+  }
+  /**
+   * Get the SDK metadata.
+   * @see SdkMetadata
+   */
+  getSdkMetadata() {
+    return this._options._metadata;
+  }
+  /**
+   * Returns the transport that is used by the client.
+   * Please note that the transport gets lazy initialized so it will only be there once the first event has been sent.
+   */
+  getTransport() {
+    return this._transport;
+  }
+  /**
+   * Wait for all events to be sent or the timeout to expire, whichever comes first.
+   *
+   * @param timeout Maximum time in ms the client should wait for events to be flushed. Omitting this parameter will
+   *   cause the client to wait until all events are sent before resolving the promise.
+   * @returns A promise that will resolve with `true` if all events are sent before the timeout, or `false` if there are
+   * still events in the queue when the timeout is reached.
+   */
+  flush(e) {
+    const n = this._transport;
+    return n ? (this.emit("flush"), this._isClientDoneProcessing(e).then((r) => n.flush(e).then((s) => r && s))) : $(!0);
+  }
+  /**
+   * Flush the event queue and set the client to `enabled = false`. See {@link Client.flush}.
+   *
+   * @param {number} timeout Maximum time in ms the client should wait before shutting down. Omitting this parameter will cause
+   *   the client to wait until all events are sent before disabling itself.
+   * @returns {Promise<boolean>} A promise which resolves to `true` if the flush completes successfully before the timeout, or `false` if
+   * it doesn't.
+   */
+  close(e) {
+    return this.flush(e).then((n) => (this.getOptions().enabled = !1, this.emit("close"), n));
+  }
+  /**
+   * Get all installed event processors.
+   */
+  getEventProcessors() {
+    return this._eventProcessors;
+  }
+  /**
+   * Adds an event processor that applies to any event processed by this client.
+   */
+  addEventProcessor(e) {
+    this._eventProcessors.push(e);
+  }
+  /**
+   * Initialize this client.
+   * Call this after the client was set on a scope.
+   */
+  init() {
+    (this._isEnabled() || // Force integrations to be setup even if no DSN was set when we have
+    // Spotlight enabled. This is particularly important for browser as we
+    // don't support the `spotlight` option there and rely on the users
+    // adding the `spotlightBrowserIntegration()` to their integrations which
+    // wouldn't get initialized with the check below when there's no DSN set.
+    this._options.integrations.some(({ name: e }) => e.startsWith("Spotlight"))) && this._setupIntegrations();
+  }
+  /**
+   * Gets an installed integration by its name.
+   *
+   * @returns {Integration|undefined} The installed integration or `undefined` if no integration with that `name` was installed.
+   */
+  getIntegrationByName(e) {
+    return this._integrations[e];
+  }
+  /**
+   * Add an integration to the client.
+   * This can be used to e.g. lazy load integrations.
+   * In most cases, this should not be necessary,
+   * and you're better off just passing the integrations via `integrations: []` at initialization time.
+   * However, if you find the need to conditionally load & add an integration, you can use `addIntegration` to do so.
+   */
+  addIntegration(e) {
+    const n = this._integrations[e.name];
+    An(this, e, this._integrations), n || Pe(this, [e]);
+  }
+  /**
+   * Send a fully prepared event to Sentry.
+   */
+  sendEvent(e, n = {}) {
+    this.emit("beforeSendEvent", e, n);
+    let r = Is(e, this._dsn, this._options._metadata, this._options.tunnel);
+    for (const o of n.attachments || [])
+      r = ms(r, ys(o));
+    const s = this.sendEnvelope(r);
+    s && s.then((o) => this.emit("afterSendEvent", e, o), null);
+  }
+  /**
+   * Send a session or session aggregrates to Sentry.
+   */
+  sendSession(e) {
+    const { release: n, environment: r = ee } = this._options;
+    if ("aggregates" in e) {
+      const o = e.attrs || {};
+      if (!o.release && !n) {
+        h && p.warn(Fe);
+        return;
+      }
+      o.release = o.release || n, o.environment = o.environment || r, e.attrs = o;
+    } else {
+      if (!e.release && !n) {
+        h && p.warn(Fe);
+        return;
+      }
+      e.release = e.release || n, e.environment = e.environment || r;
+    }
+    this.emit("beforeSendSession", e);
+    const s = Ts(e, this._dsn, this._options._metadata, this._options.tunnel);
+    this.sendEnvelope(s);
+  }
+  /**
+   * Record on the client that an event got dropped (ie, an event that will not be sent to Sentry).
+   */
+  recordDroppedEvent(e, n, r = 1) {
+    if (this._options.sendClientReports) {
+      const s = `${e}:${n}`;
+      h && p.log(`Recording outcome: "${s}"${r > 1 ? ` (${r} times)` : ""}`), this._outcomes[s] = (this._outcomes[s] || 0) + r;
+    }
+  }
+  /* eslint-disable @typescript-eslint/unified-signatures */
+  /**
+   * Register a callback for whenever a span is started.
+   * Receives the span as argument.
+   * @returns {() => void} A function that, when executed, removes the registered callback.
+   */
+  /**
+   * Register a hook on this client.
+   */
+  on(e, n) {
+    const r = this._hooks[e] = this._hooks[e] || [];
+    return r.push(n), () => {
+      const s = r.indexOf(n);
+      s > -1 && r.splice(s, 1);
+    };
+  }
+  /** Fire a hook whenever a span starts. */
+  /**
+   * Emit a hook that was previously registered via `on()`.
+   */
+  emit(e, ...n) {
+    const r = this._hooks[e];
+    r && r.forEach((s) => s(...n));
+  }
+  /**
+   * Send an envelope to Sentry.
+   */
+  sendEnvelope(e) {
+    return this.emit("beforeEnvelope", e), this._isEnabled() && this._transport ? this._transport.send(e).then(null, (n) => (h && p.error("Error while sending envelope:", n), n)) : (h && p.error("Transport disabled"), $({}));
+  }
+  /* eslint-enable @typescript-eslint/unified-signatures */
+  /** Setup integrations for this client. */
+  _setupIntegrations() {
+    const { integrations: e } = this._options;
+    this._integrations = Ks(this, e), Pe(this, e);
+  }
+  /** Updates existing session based on the provided event */
+  _updateSessionFromEvent(e, n) {
+    let r = n.level === "fatal", s = !1;
+    const o = n.exception?.values;
+    if (o) {
+      s = !0;
+      for (const c of o)
+        if (c.mechanism?.handled === !1) {
+          r = !0;
+          break;
+        }
+    }
+    const i = e.status === "ok";
+    (i && e.errors === 0 || i && r) && (G(e, {
+      ...r && { status: "crashed" },
+      errors: e.errors || Number(s || r)
+    }), this.captureSession(e));
+  }
+  /**
+   * Determine if the client is finished processing. Returns a promise because it will wait `timeout` ms before saying
+   * "no" (resolving to `false`) in order to give the client a chance to potentially finish first.
+   *
+   * @param timeout The time, in ms, after which to resolve to `false` if the client is still busy. Passing `0` (or not
+   * passing anything) will make the promise wait as long as it takes for processing to finish before resolving to
+   * `true`.
+   * @returns A promise which will resolve to `true` if processing is already done or finishes before the timeout, and
+   * `false` otherwise
+   */
+  _isClientDoneProcessing(e) {
+    return new C((n) => {
+      let r = 0;
+      const s = 1, o = setInterval(() => {
+        this._numProcessing == 0 ? (clearInterval(o), n(!0)) : (r += s, e && r >= e && (clearInterval(o), n(!1)));
+      }, s);
+    });
+  }
+  /** Determines whether this SDK is enabled and a transport is present. */
+  _isEnabled() {
+    return this.getOptions().enabled !== !1 && this._transport !== void 0;
+  }
+  /**
+   * Adds common information to events.
+   *
+   * The information includes release and environment from `options`,
+   * breadcrumbs and context (extra, tags and user) from the scope.
+   *
+   * Information that is already present in the event is never overwritten. For
+   * nested objects, such as the context, keys are merged.
+   *
+   * @param event The original event.
+   * @param hint May contain additional information about the original exception.
+   * @param currentScope A scope containing event metadata.
+   * @returns A new event with more information.
+   */
+  _prepareEvent(e, n, r, s) {
+    const o = this.getOptions(), i = Object.keys(this._integrations);
+    return !n.integrations && i?.length && (n.integrations = i), this.emit("preprocessEvent", e, n), e.type || s.setLastEventId(e.event_id || n.event_id), Ns(o, e, n, r, this, s).then((a) => {
+      if (a === null)
+        return a;
+      this.emit("postprocessEvent", a, n), a.contexts = {
+        trace: Nr(r),
+        ...a.contexts
+      };
+      const c = cs(this, r);
+      return a.sdkProcessingMetadata = {
+        dynamicSamplingContext: c,
+        ...a.sdkProcessingMetadata
+      }, a;
+    });
+  }
+  /**
+   * Processes the event and logs an error in case of rejection
+   * @param event
+   * @param hint
+   * @param scope
+   */
+  _captureEvent(e, n = {}, r = D(), s = tt()) {
+    return h && Mt(e) && p.log(`Captured error event \`${xn(e)[0] || "<unknown>"}\``), this._processEvent(e, n, r, s).then(
+      (o) => o.event_id,
+      (o) => {
+        h && (Ue(o) ? p.log(o.message) : $e(o) ? p.warn(o.message) : p.warn(o));
+      }
+    );
+  }
+  /**
+   * Processes an event (either error or message) and sends it to Sentry.
+   *
+   * This also adds breadcrumbs and context information to the event. However,
+   * platform specific meta data (such as the User's IP address) must be added
+   * by the SDK implementor.
+   *
+   *
+   * @param event The event to send to Sentry.
+   * @param hint May contain additional information about the original exception.
+   * @param currentScope A scope containing event metadata.
+   * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.
+   */
+  _processEvent(e, n, r, s) {
+    const o = this.getOptions(), { sampleRate: i } = o, a = Cn(e), c = Mt(e), u = e.type || "error", f = `before send for type \`${u}\``, l = typeof i > "u" ? void 0 : qr(i);
+    if (c && typeof l == "number" && Math.random() > l)
+      return this.recordDroppedEvent("sample_rate", "error"), pt(
+        kt(
+          `Discarding event because it's not included in the random sample (sampling rate = ${i})`
+        )
+      );
+    const m = u === "replay_event" ? "replay" : u;
+    return this._prepareEvent(e, n, r, s).then((d) => {
+      if (d === null)
+        throw this.recordDroppedEvent("event_processor", m), kt("An event processor returned `null`, will not send event.");
+      if (n.data && n.data.__sentry__ === !0)
+        return d;
+      const R = eo(this, o, d, n);
+      return to(R, f);
+    }).then((d) => {
+      if (d === null) {
+        if (this.recordDroppedEvent("before_send", m), a) {
+          const Tt = 1 + (e.spans || []).length;
+          this.recordDroppedEvent("before_send", "span", Tt);
+        }
+        throw kt(`${f} returned \`null\`, will not send event.`);
+      }
+      const E = r.getSession() || s.getSession();
+      if (c && E && this._updateSessionFromEvent(E, d), a) {
+        const g = d.sdkProcessingMetadata?.spanCountBeforeProcessing || 0, Tt = d.spans ? d.spans.length : 0, oe = g - Tt;
+        oe > 0 && this.recordDroppedEvent("before_send", "span", oe);
+      }
+      const R = d.transaction_info;
+      if (a && R && d.transaction !== e.transaction) {
+        const g = "custom";
+        d.transaction_info = {
+          ...R,
+          source: g
+        };
+      }
+      return this.sendEvent(d, n), d;
+    }).then(null, (d) => {
+      throw Ue(d) || $e(d) ? d : (this.captureException(d, {
+        data: {
+          __sentry__: !0
+        },
+        originalException: d
+      }), ut(
+        `Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.
+Reason: ${d}`
+      ));
+    });
+  }
+  /**
+   * Occupies the client with processing and event
+   */
+  _process(e) {
+    this._numProcessing++, e.then(
+      (n) => (this._numProcessing--, n),
+      (n) => (this._numProcessing--, n)
+    );
+  }
+  /**
+   * Clears outcomes on this client and returns them.
+   */
+  _clearOutcomes() {
+    const e = this._outcomes;
+    return this._outcomes = {}, Object.entries(e).map(([n, r]) => {
+      const [s, o] = n.split(":");
+      return {
+        reason: s,
+        category: o,
+        quantity: r
+      };
+    });
+  }
+  /**
+   * Sends client reports as an envelope.
+   */
+  _flushOutcomes() {
+    h && p.log("Flushing outcomes...");
+    const e = this._clearOutcomes();
+    if (e.length === 0) {
+      h && p.log("No outcomes to send");
+      return;
+    }
+    if (!this._dsn) {
+      h && p.log("No dsn provided, will not send outcomes");
+      return;
+    }
+    h && p.log("Sending outcomes:", e);
+    const n = Vs(e, this._options.tunnel && St(this._dsn));
+    this.sendEnvelope(n);
+  }
+  /**
+   * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.
+   */
+}
+function to(t, e) {
+  const n = `${e} must return \`null\` or a valid event.`;
+  if (yt(t))
+    return t.then(
+      (r) => {
+        if (!K(r) && r !== null)
+          throw ut(n);
+        return r;
+      },
+      (r) => {
+        throw ut(`${e} rejected with ${r}`);
+      }
+    );
+  if (!K(t) && t !== null)
+    throw ut(n);
+  return t;
+}
+function eo(t, e, n, r) {
+  const { beforeSend: s, beforeSendTransaction: o, beforeSendSpan: i } = e;
+  let a = n;
+  if (Mt(a) && s)
+    return s(a, r);
+  if (Cn(a)) {
+    if (i) {
+      const c = i(Js(a));
+      if (c ? a = Q(n, Zs(c)) : we(), a.spans) {
+        const u = [];
+        for (const f of a.spans) {
+          const l = i(f);
+          l ? u.push(l) : (we(), u.push(f));
+        }
+        a.spans = u;
+      }
+    }
+    if (o) {
+      if (a.spans) {
+        const c = a.spans.length;
+        a.sdkProcessingMetadata = {
+          ...n.sdkProcessingMetadata,
+          spanCountBeforeProcessing: c
+        };
+      }
+      return o(a, r);
+    }
+  }
+  return a;
+}
+function Mt(t) {
+  return t.type === void 0;
+}
+function Cn(t) {
+  return t.type === "transaction";
+}
+function no(t) {
+  return [
+    {
+      type: "log",
+      item_count: t.length,
+      content_type: "application/vnd.sentry.items.log+json"
+    },
+    {
+      items: t
+    }
+  ];
+}
+function ro(t, e, n, r) {
+  const s = {};
+  return e?.sdk && (s.sdk = {
+    name: e.sdk.name,
+    version: e.sdk.version
+  }), n && r && (s.dsn = St(r)), et(s, [no(t)]);
+}
+function At(t, e) {
+  const n = so(t) ?? [];
+  if (n.length === 0)
+    return;
+  const r = t.getOptions(), s = ro(n, r._metadata, r.tunnel, t.getDsn());
+  Dn().set(t, []), t.emit("flushLogs"), t.sendEnvelope(s);
+}
+function so(t) {
+  return Dn().get(t);
+}
+function Dn() {
+  return J("clientToLogBufferMap", () => /* @__PURE__ */ new WeakMap());
+}
+function oo(t, e) {
+  e.debug === !0 && (h ? p.enable() : Y(() => {
+    console.warn("[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.");
+  })), D().update(e.initialScope);
+  const r = new t(e);
+  return io(r), r.init(), r;
+}
+function io(t) {
+  D().setClient(t);
+}
+const Ln = Symbol.for("SentryBufferFullError");
+function ao(t) {
+  const e = [];
+  function n() {
+    return t === void 0 || e.length < t;
+  }
+  function r(i) {
+    return e.splice(e.indexOf(i), 1)[0] || Promise.resolve(void 0);
+  }
+  function s(i) {
+    if (!n())
+      return pt(Ln);
+    const a = i();
+    return e.indexOf(a) === -1 && e.push(a), a.then(() => r(a)).then(
+      null,
+      () => r(a).then(null, () => {
+      })
+    ), a;
+  }
+  function o(i) {
+    return new C((a, c) => {
+      let u = e.length;
+      if (!u)
+        return a(!0);
+      const f = setTimeout(() => {
+        i && i > 0 && a(!1);
+      }, i);
+      e.forEach((l) => {
+        $(l).then(() => {
+          --u || (clearTimeout(f), a(!0));
+        }, c);
+      });
+    });
+  }
+  return {
+    $: e,
+    add: s,
+    drain: o
+  };
+}
+const co = 60 * 1e3;
+function uo(t, e = Date.now()) {
+  const n = parseInt(`${t}`, 10);
+  if (!isNaN(n))
+    return n * 1e3;
+  const r = Date.parse(`${t}`);
+  return isNaN(r) ? co : r - e;
+}
+function fo(t, e) {
+  return t[e] || t.all || 0;
+}
+function lo(t, e, n = Date.now()) {
+  return fo(t, e) > n;
+}
+function po(t, { statusCode: e, headers: n }, r = Date.now()) {
+  const s = {
+    ...t
+  }, o = n?.["x-sentry-rate-limits"], i = n?.["retry-after"];
+  if (o)
+    for (const a of o.trim().split(",")) {
+      const [c, u, , , f] = a.split(":", 5), l = parseInt(c, 10), m = (isNaN(l) ? 60 : l) * 1e3;
+      if (!u)
+        s.all = r + m;
+      else
+        for (const d of u.split(";"))
+          d === "metric_bucket" ? (!f || f.split(";").includes("custom")) && (s[d] = r + m) : s[d] = r + m;
+    }
+  else i ? s.all = r + uo(i, r) : e === 429 && (s.all = r + 60 * 1e3);
+  return s;
+}
+const ho = 64;
+function mo(t, e, n = ao(
+  t.bufferSize || ho
+)) {
+  let r = {};
+  const s = (i) => n.drain(i);
+  function o(i) {
+    const a = [];
+    if (Re(i, (l, m) => {
+      const d = ke(m);
+      lo(r, d) ? t.recordDroppedEvent("ratelimit_backoff", d) : a.push(l);
+    }), a.length === 0)
+      return $({});
+    const c = et(i[0], a), u = (l) => {
+      Re(c, (m, d) => {
+        t.recordDroppedEvent(l, ke(d));
+      });
+    }, f = () => e({ body: gs(c) }).then(
+      (l) => (l.statusCode !== void 0 && (l.statusCode < 200 || l.statusCode >= 300) && h && p.warn(`Sentry responded with status code ${l.statusCode} to sent event.`), r = po(r, l), l),
+      (l) => {
+        throw u("network_error"), h && p.error("Encountered error running transport request:", l), l;
+      }
+    );
+    return n.add(f).then(
+      (l) => l,
+      (l) => {
+        if (l === Ln)
+          return h && p.error("Skipped sending event because buffer is full."), u("queue_overflow"), $({});
+        throw l;
+      }
+    );
+  }
+  return {
+    send: o,
+    flush: s
+  };
+}
+function go(t) {
+  t.user?.ip_address === void 0 && (t.user = {
+    ...t.user,
+    ip_address: "{{auto}}"
+  });
+}
+function _o(t) {
+  "aggregates" in t ? t.attrs?.ip_address === void 0 && (t.attrs = {
+    ...t.attrs,
+    ip_address: "{{auto}}"
+  }) : t.ipAddress === void 0 && (t.ipAddress = "{{auto}}");
+}
+function yo(t, e, n = [e], r = "npm") {
+  const s = t._metadata || {};
+  s.sdk || (s.sdk = {
+    name: `sentry.javascript.${e}`,
+    packages: n.map((o) => ({
+      name: `${r}:@sentry/${o}`,
+      version: P
+    })),
+    version: P
+  }), t._metadata = s;
+}
+const Eo = 100;
+function U(t, e) {
+  const n = b(), r = tt();
+  if (!n) return;
+  const { beforeBreadcrumb: s = null, maxBreadcrumbs: o = Eo } = n.getOptions();
+  if (o <= 0) return;
+  const a = { timestamp: Z(), ...t }, c = s ? Y(() => s(a, e)) : a;
+  c !== null && (n.emit && n.emit("beforeAddBreadcrumb", c, e), r.addBreadcrumb(c, o));
+}
+let je;
+const So = "FunctionToString", Be = /* @__PURE__ */ new WeakMap(), bo = (() => ({
+  name: So,
+  setupOnce() {
+    je = Function.prototype.toString;
+    try {
+      Function.prototype.toString = function(...t) {
+        const e = Zt(this), n = Be.has(b()) && e !== void 0 ? e : this;
+        return je.apply(n, t);
+      };
+    } catch {
+    }
+  },
+  setup(t) {
+    Be.set(t, !0);
+  }
+})), To = bo, Io = [
+  /^Script error\.?$/,
+  /^Javascript error: Script error\.? on line 0$/,
+  /^ResizeObserver loop completed with undelivered notifications.$/,
+  // The browser logs this when a ResizeObserver handler takes a bit longer. Usually this is not an actual issue though. It indicates slowness.
+  /^Cannot redefine property: googletag$/,
+  // This is thrown when google tag manager is used in combination with an ad blocker
+  /^Can't find variable: gmo$/,
+  // Error from Google Search App https://issuetracker.google.com/issues/396043331
+  /^undefined is not an object \(evaluating 'a\.[A-Z]'\)$/,
+  // Random error that happens but not actionable or noticeable to end-users.
+  `can't redefine non-configurable property "solana"`,
+  // Probably a browser extension or custom browser (Brave) throwing this error
+  "vv().getRestrictions is not a function. (In 'vv().getRestrictions(1,a)', 'vv().getRestrictions' is undefined)",
+  // Error thrown by GTM, seemingly not affecting end-users
+  "Can't find variable: _AutofillCallbackHandler",
+  // Unactionable error in instagram webview https://developers.facebook.com/community/threads/320013549791141/
+  /^Non-Error promise rejection captured with value: Object Not Found Matching Id:\d+, MethodName:simulateEvent, ParamCount:\d+$/,
+  // unactionable error from CEFSharp, a .NET library that embeds chromium in .NET apps
+  /^Java exception was raised during method invocation$/
+  // error from Facebook Mobile browser (https://github.com/getsentry/sentry-javascript/issues/15065)
+], vo = "EventFilters", wo = (t = {}) => {
+  let e;
+  return {
+    name: vo,
+    setup(n) {
+      const r = n.getOptions();
+      e = He(t, r);
+    },
+    processEvent(n, r, s) {
+      if (!e) {
+        const o = s.getOptions();
+        e = He(t, o);
+      }
+      return ko(n, e) ? null : n;
+    }
+  };
+}, Ro = ((t = {}) => ({
+  ...wo(t),
+  name: "InboundFilters"
+}));
+function He(t = {}, e = {}) {
+  return {
+    allowUrls: [...t.allowUrls || [], ...e.allowUrls || []],
+    denyUrls: [...t.denyUrls || [], ...e.denyUrls || []],
+    ignoreErrors: [
+      ...t.ignoreErrors || [],
+      ...e.ignoreErrors || [],
+      ...t.disableErrorDefaults ? [] : Io
+    ],
+    ignoreTransactions: [...t.ignoreTransactions || [], ...e.ignoreTransactions || []]
+  };
+}
+function ko(t, e) {
+  if (t.type) {
+    if (t.type === "transaction" && xo(t, e.ignoreTransactions))
+      return h && p.warn(
+        `Event dropped due to being matched by \`ignoreTransactions\` option.
+Event: ${L(t)}`
+      ), !0;
+  } else {
+    if (Ao(t, e.ignoreErrors))
+      return h && p.warn(
+        `Event dropped due to being matched by \`ignoreErrors\` option.
+Event: ${L(t)}`
+      ), !0;
+    if (Do(t))
+      return h && p.warn(
+        `Event dropped due to not having an error message, error type or stacktrace.
+Event: ${L(
+          t
+        )}`
+      ), !0;
+    if (Oo(t, e.denyUrls))
+      return h && p.warn(
+        `Event dropped due to being matched by \`denyUrls\` option.
+Event: ${L(
+          t
+        )}.
+Url: ${ht(t)}`
+      ), !0;
+    if (!No(t, e.allowUrls))
+      return h && p.warn(
+        `Event dropped due to not being matched by \`allowUrls\` option.
+Event: ${L(
+          t
+        )}.
+Url: ${ht(t)}`
+      ), !0;
+  }
+  return !1;
+}
+function Ao(t, e) {
+  return e?.length ? xn(t).some((n) => Et(n, e)) : !1;
+}
+function xo(t, e) {
+  if (!e?.length)
+    return !1;
+  const n = t.transaction;
+  return n ? Et(n, e) : !1;
+}
+function Oo(t, e) {
+  if (!e?.length)
+    return !1;
+  const n = ht(t);
+  return n ? Et(n, e) : !1;
+}
+function No(t, e) {
+  if (!e?.length)
+    return !0;
+  const n = ht(t);
+  return n ? Et(n, e) : !0;
+}
+function Co(t = []) {
+  for (let e = t.length - 1; e >= 0; e--) {
+    const n = t[e];
+    if (n && n.filename !== "<anonymous>" && n.filename !== "[native code]")
+      return n.filename || null;
+  }
+  return null;
+}
+function ht(t) {
+  try {
+    const n = [...t.exception?.values ?? []].reverse().find((r) => r.mechanism?.parent_id === void 0 && r.stacktrace?.frames?.length)?.stacktrace?.frames;
+    return n ? Co(n) : null;
+  } catch {
+    return h && p.error(`Cannot extract url for event ${L(t)}`), null;
+  }
+}
+function Do(t) {
+  return t.exception?.values?.length ? (
+    // No top-level message
+    !t.message && // There are no exception values that have a stacktrace, a non-generic-Error type or value
+    !t.exception.values.some((e) => e.stacktrace || e.type && e.type !== "Error" || e.value)
+  ) : !1;
+}
+function Lo(t, e, n, r, s, o) {
+  if (!s.exception?.values || !o || !N(o.originalException, Error))
+    return;
+  const i = s.exception.values.length > 0 ? s.exception.values[s.exception.values.length - 1] : void 0;
+  i && (s.exception.values = Ft(
+    t,
+    e,
+    r,
+    o.originalException,
+    n,
+    s.exception.values,
+    i,
+    0
+  ));
+}
+function Ft(t, e, n, r, s, o, i, a) {
+  if (o.length >= n + 1)
+    return o;
+  let c = [...o];
+  if (N(r[s], Error)) {
+    Ge(i, a);
+    const u = t(e, r[s]), f = c.length;
+    We(u, s, f, a), c = Ft(
+      t,
+      e,
+      n,
+      r[s],
+      s,
+      [u, ...c],
+      u,
+      f
+    );
+  }
+  return Array.isArray(r.errors) && r.errors.forEach((u, f) => {
+    if (N(u, Error)) {
+      Ge(i, a);
+      const l = t(e, u), m = c.length;
+      We(l, `errors[${f}]`, m, a), c = Ft(
+        t,
+        e,
+        n,
+        u,
+        s,
+        [l, ...c],
+        l,
+        m
+      );
+    }
+  }), c;
+}
+function Ge(t, e) {
+  t.mechanism = t.mechanism || { type: "generic", handled: !0 }, t.mechanism = {
+    ...t.mechanism,
+    ...t.type === "AggregateError" && { is_exception_group: !0 },
+    exception_id: e
+  };
+}
+function We(t, e, n, r) {
+  t.mechanism = t.mechanism || { type: "generic", handled: !0 }, t.mechanism = {
+    ...t.mechanism,
+    type: "chained",
+    source: e,
+    exception_id: n,
+    parent_id: r
+  };
+}
+function Po(t) {
+  const e = "console";
+  j(e, t), B(e, Mo);
+}
+function Mo() {
+  "console" in _ && zn.forEach(function(t) {
+    t in _.console && T(_.console, t, function(e) {
+      return lt[t] = e, function(...n) {
+        v("console", { args: n, level: t }), lt[t]?.apply(_.console, n);
+      };
+    });
+  });
+}
+function Fo(t) {
+  return t === "warn" ? "warning" : ["fatal", "error", "warning", "log", "info", "debug"].includes(t) ? t : "log";
+}
+const $o = "Dedupe", Uo = (() => {
+  let t;
+  return {
+    name: $o,
+    processEvent(e) {
+      if (e.type)
+        return e;
+      try {
+        if (Bo(e, t))
+          return h && p.warn("Event dropped due to being a duplicate of previously captured event."), null;
+      } catch {
+      }
+      return t = e;
+    }
+  };
+}), jo = Uo;
+function Bo(t, e) {
+  return e ? !!(Ho(t, e) || Go(t, e)) : !1;
+}
+function Ho(t, e) {
+  const n = t.message, r = e.message;
+  return !(!n && !r || n && !r || !n && r || n !== r || !Mn(t, e) || !Pn(t, e));
+}
+function Go(t, e) {
+  const n = qe(e), r = qe(t);
+  return !(!n || !r || n.type !== r.type || n.value !== r.value || !Mn(t, e) || !Pn(t, e));
+}
+function Pn(t, e) {
+  let n = ue(t), r = ue(e);
+  if (!n && !r)
+    return !0;
+  if (n && !r || !n && r || (n = n, r = r, r.length !== n.length))
+    return !1;
+  for (let s = 0; s < r.length; s++) {
+    const o = r[s], i = n[s];
+    if (o.filename !== i.filename || o.lineno !== i.lineno || o.colno !== i.colno || o.function !== i.function)
+      return !1;
+  }
+  return !0;
+}
+function Mn(t, e) {
+  let n = t.fingerprint, r = e.fingerprint;
+  if (!n && !r)
+    return !0;
+  if (n && !r || !n && r)
+    return !1;
+  n = n, r = r;
+  try {
+    return n.join("") === r.join("");
+  } catch {
+    return !1;
+  }
+}
+function qe(t) {
+  return t.exception?.values?.[0];
+}
+function xt(t) {
+  if (!t)
+    return {};
+  const e = t.match(/^(([^:/?#]+):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$/);
+  if (!e)
+    return {};
+  const n = e[6] || "", r = e[8] || "";
+  return {
+    host: e[4],
+    path: e[5],
+    protocol: e[2],
+    search: n,
+    hash: r,
+    relative: e[5] + n + r
+    // everything minus origin
+  };
+}
+function Fn(t) {
+  if (t !== void 0)
+    return t >= 400 && t < 500 ? "warning" : t >= 500 ? "error" : void 0;
+}
+const V = _;
+function Wo() {
+  return "history" in V && !!V.history;
+}
+function qo() {
+  if (!("fetch" in V))
+    return !1;
+  try {
+    return new Headers(), new Request("http://www.example.com"), new Response(), !0;
+  } catch {
+    return !1;
+  }
+}
+function $t(t) {
+  return t && /^function\s+\w+\(\)\s+\{\s+\[native code\]\s+\}$/.test(t.toString());
+}
+function Yo() {
+  if (typeof EdgeRuntime == "string")
+    return !0;
+  if (!qo())
+    return !1;
+  if ($t(V.fetch))
+    return !0;
+  let t = !1;
+  const e = V.document;
+  if (e && typeof e.createElement == "function")
+    try {
+      const n = e.createElement("iframe");
+      n.hidden = !0, e.head.appendChild(n), n.contentWindow?.fetch && (t = $t(n.contentWindow.fetch)), e.head.removeChild(n);
+    } catch (n) {
+      h && p.warn("Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ", n);
+    }
+  return t;
+}
+function zo(t, e) {
+  const n = "fetch";
+  j(n, t), B(n, () => Xo(void 0, e));
+}
+function Xo(t, e = !1) {
+  e && !Yo() || T(_, "fetch", function(n) {
+    return function(...r) {
+      const s = new Error(), { method: o, url: i } = Ko(r), a = {
+        args: r,
+        fetchData: {
+          method: o,
+          url: i
+        },
+        startTimestamp: x() * 1e3,
+        // // Adding the error to be able to fingerprint the failed fetch event in HttpClient instrumentation
+        virtualError: s,
+        headers: Vo(r)
+      };
+      return v("fetch", {
+        ...a
+      }), n.apply(_, r).then(
+        async (c) => (v("fetch", {
+          ...a,
+          endTimestamp: x() * 1e3,
+          response: c
+        }), c),
+        (c) => {
+          if (v("fetch", {
+            ...a,
+            endTimestamp: x() * 1e3,
+            error: c
+          }), zt(c) && c.stack === void 0 && (c.stack = s.stack, F(c, "framesToPop", 1)), c instanceof TypeError && (c.message === "Failed to fetch" || c.message === "Load failed" || c.message === "NetworkError when attempting to fetch resource."))
+            try {
+              const u = new URL(a.fetchData.url);
+              c.message = `${c.message} (${u.host})`;
+            } catch {
+            }
+          throw c;
+        }
+      );
+    };
+  });
+}
+function Ut(t, e) {
+  return !!t && typeof t == "object" && !!t[e];
+}
+function Ye(t) {
+  return typeof t == "string" ? t : t ? Ut(t, "url") ? t.url : t.toString ? t.toString() : "" : "";
+}
+function Ko(t) {
+  if (t.length === 0)
+    return { method: "GET", url: "" };
+  if (t.length === 2) {
+    const [n, r] = t;
+    return {
+      url: Ye(n),
+      method: Ut(r, "method") ? String(r.method).toUpperCase() : "GET"
+    };
+  }
+  const e = t[0];
+  return {
+    url: Ye(e),
+    method: Ut(e, "method") ? String(e.method).toUpperCase() : "GET"
+  };
+}
+function Vo(t) {
+  const [e, n] = t;
+  try {
+    if (typeof n == "object" && n !== null && "headers" in n && n.headers)
+      return new Headers(n.headers);
+    if (fr(e))
+      return new Headers(e.headers);
+  } catch {
+  }
+}
+function Jo() {
+  return "npm";
+}
+const y = _;
+let jt = 0;
+function $n() {
+  return jt > 0;
+}
+function Zo() {
+  jt++, setTimeout(() => {
+    jt--;
+  });
+}
+function q(t, e = {}) {
+  function n(s) {
+    return typeof s == "function";
+  }
+  if (!n(t))
+    return t;
+  try {
+    const s = t.__sentry_wrapped__;
+    if (s)
+      return typeof s == "function" ? s : t;
+    if (Zt(t))
+      return t;
+  } catch {
+    return t;
+  }
+  const r = function(...s) {
+    try {
+      const o = s.map((i) => q(i, e));
+      return t.apply(this, o);
+    } catch (o) {
+      throw Zo(), Or((i) => {
+        i.addEventProcessor((a) => (e.mechanism && (Nt(a, void 0), H(a, e.mechanism)), a.extra = {
+          ...a.extra,
+          arguments: s
+        }, a)), vn(o);
+      }), o;
+    }
+  };
+  try {
+    for (const s in t)
+      Object.prototype.hasOwnProperty.call(t, s) && (r[s] = t[s]);
+  } catch {
+  }
+  fn(r, t), F(t, "__sentry_wrapped__", r);
+  try {
+    Object.getOwnPropertyDescriptor(r, "name").configurable && Object.defineProperty(r, "name", {
+      get() {
+        return t.name;
+      }
+    });
+  } catch {
+  }
+  return r;
+}
+function Qo() {
+  const t = Jt(), { referrer: e } = y.document || {}, { userAgent: n } = y.navigator || {}, r = {
+    ...e && { Referer: e },
+    ...n && { "User-Agent": n }
+  };
+  return {
+    url: t,
+    headers: r
+  };
+}
+function ne(t, e) {
+  const n = re(t, e), r = {
+    type: si(e),
+    value: oi(e)
+  };
+  return n.length && (r.stacktrace = { frames: n }), r.type === void 0 && r.value === "" && (r.value = "Unrecoverable error caught"), r;
+}
+function ti(t, e, n, r) {
+  const o = b()?.getOptions().normalizeDepth, i = fi(e), a = {
+    __serialized__: Tn(e, o)
+  };
+  if (i)
+    return {
+      exception: {
+        values: [ne(t, i)]
+      },
+      extra: a
+    };
+  const c = {
+    exception: {
+      values: [
+        {
+          type: _t(e) ? e.constructor.name : r ? "UnhandledRejection" : "Error",
+          value: ci(e, { isUnhandledRejection: r })
+        }
+      ]
+    },
+    extra: a
+  };
+  if (n) {
+    const u = re(t, n);
+    u.length && (c.exception.values[0].stacktrace = { frames: u });
+  }
+  return c;
+}
+function Ot(t, e) {
+  return {
+    exception: {
+      values: [ne(t, e)]
+    }
+  };
+}
+function re(t, e) {
+  const n = e.stacktrace || e.stack || "", r = ni(e), s = ri(e);
+  try {
+    return t(n, r, s);
+  } catch {
+  }
+  return [];
+}
+const ei = /Minified React error #\d+;/i;
+function ni(t) {
+  return t && ei.test(t.message) ? 1 : 0;
+}
+function ri(t) {
+  return typeof t.framesToPop == "number" ? t.framesToPop : 0;
+}
+function Un(t) {
+  return typeof WebAssembly < "u" && typeof WebAssembly.Exception < "u" ? t instanceof WebAssembly.Exception : !1;
+}
+function si(t) {
+  const e = t?.name;
+  return !e && Un(t) ? t.message && Array.isArray(t.message) && t.message.length == 2 ? t.message[0] : "WebAssembly.Exception" : e;
+}
+function oi(t) {
+  const e = t?.message;
+  return Un(t) ? Array.isArray(t.message) && t.message.length == 2 ? t.message[1] : "wasm exception" : e ? e.error && typeof e.error.message == "string" ? e.error.message : e : "No error message";
+}
+function ii(t, e, n, r) {
+  const s = n?.syntheticException || void 0, o = se(t, e, s, r);
+  return H(o), o.level = "error", n?.event_id && (o.event_id = n.event_id), $(o);
+}
+function ai(t, e, n = "info", r, s) {
+  const o = r?.syntheticException || void 0, i = Bt(t, e, o, s);
+  return i.level = n, r?.event_id && (i.event_id = r.event_id), $(i);
+}
+function se(t, e, n, r, s) {
+  let o;
+  if (an(e) && e.error)
+    return Ot(t, e.error);
+  if (le(e) || ir(e)) {
+    const i = e;
+    if ("stack" in e)
+      o = Ot(t, e);
+    else {
+      const a = i.name || (le(i) ? "DOMError" : "DOMException"), c = i.message ? `${a}: ${i.message}` : a;
+      o = Bt(t, c, n, r), Nt(o, c);
+    }
+    return "code" in i && (o.tags = { ...o.tags, "DOMException.code": `${i.code}` }), o;
+  }
+  return zt(e) ? Ot(t, e) : K(e) || _t(e) ? (o = ti(t, e, n, s), H(o, {
+    synthetic: !0
+  }), o) : (o = Bt(t, e, n, r), Nt(o, `${e}`), H(o, {
+    synthetic: !0
+  }), o);
+}
+function Bt(t, e, n, r) {
+  const s = {};
+  if (r && n) {
+    const o = re(t, n);
+    o.length && (s.exception = {
+      values: [{ value: e, stacktrace: { frames: o } }]
+    }), H(s, { synthetic: !0 });
+  }
+  if (Xt(e)) {
+    const { __sentry_template_string__: o, __sentry_template_values__: i } = e;
+    return s.logentry = {
+      message: o,
+      params: i
+    }, s;
+  }
+  return s.message = e, s;
+}
+function ci(t, { isUnhandledRejection: e }) {
+  const n = mr(t), r = e ? "promise rejection" : "exception";
+  return an(t) ? `Event \`ErrorEvent\` captured as ${r} with message \`${t.message}\`` : _t(t) ? `Event \`${ui(t)}\` (type=${t.type}) captured as ${r}` : `Object captured as ${r} with keys: ${n}`;
+}
+function ui(t) {
+  try {
+    const e = Object.getPrototypeOf(t);
+    return e ? e.constructor.name : void 0;
+  } catch {
+  }
+}
+function fi(t) {
+  for (const e in t)
+    if (Object.prototype.hasOwnProperty.call(t, e)) {
+      const n = t[e];
+      if (n instanceof Error)
+        return n;
+    }
+}
+const li = 5e3;
+class di extends Qs {
+  /**
+   * Creates a new Browser SDK instance.
+   *
+   * @param options Configuration options for this SDK.
+   */
+  constructor(e) {
+    const n = pi(e), r = y.SENTRY_SDK_SOURCE || Jo();
+    yo(n, "browser", ["browser"], r), super(n);
+    const { sendDefaultPii: s, sendClientReports: o, enableLogs: i, _experiments: a } = this._options, c = i ?? a?.enableLogs;
+    y.document && (o || c) && y.document.addEventListener("visibilitychange", () => {
+      y.document.visibilityState === "hidden" && (o && this._flushOutcomes(), c && At(this));
+    }), c && (this.on("flush", () => {
+      At(this);
+    }), this.on("afterCaptureLog", () => {
+      this._logFlushIdleTimeout && clearTimeout(this._logFlushIdleTimeout), this._logFlushIdleTimeout = setTimeout(() => {
+        At(this);
+      }, li);
+    })), s && (this.on("postprocessEvent", go), this.on("beforeSendSession", _o));
+  }
+  /**
+   * @inheritDoc
+   */
+  eventFromException(e, n) {
+    return ii(this._options.stackParser, e, n, this._options.attachStacktrace);
+  }
+  /**
+   * @inheritDoc
+   */
+  eventFromMessage(e, n = "info", r) {
+    return ai(this._options.stackParser, e, n, r, this._options.attachStacktrace);
+  }
+  /**
+   * @inheritDoc
+   */
+  _prepareEvent(e, n, r, s) {
+    return e.platform = e.platform || "javascript", super._prepareEvent(e, n, r, s);
+  }
+}
+function pi(t) {
+  return {
+    release: typeof __SENTRY_RELEASE__ == "string" ? __SENTRY_RELEASE__ : y.SENTRY_RELEASE?.id,
+    // This supports the variable that sentry-webpack-plugin injects
+    sendClientReports: !0,
+    // We default this to true, as it is the safer scenario
+    parentSpanIsAlwaysRootSpan: !0,
+    ...t
+  };
+}
+const hi = typeof __SENTRY_DEBUG__ > "u" || __SENTRY_DEBUG__, S = _, mi = 1e3;
+let ze, Ht, Gt;
+function gi(t) {
+  j("dom", t), B("dom", _i);
+}
+function _i() {
+  if (!S.document)
+    return;
+  const t = v.bind(null, "dom"), e = Xe(t, !0);
+  S.document.addEventListener("click", e, !1), S.document.addEventListener("keypress", e, !1), ["EventTarget", "Node"].forEach((n) => {
+    const s = S[n]?.prototype;
+    s?.hasOwnProperty?.("addEventListener") && (T(s, "addEventListener", function(o) {
+      return function(i, a, c) {
+        if (i === "click" || i == "keypress")
+          try {
+            const u = this.__sentry_instrumentation_handlers__ = this.__sentry_instrumentation_handlers__ || {}, f = u[i] = u[i] || { refCount: 0 };
+            if (!f.handler) {
+              const l = Xe(t);
+              f.handler = l, o.call(this, i, l, c);
+            }
+            f.refCount++;
+          } catch {
+          }
+        return o.call(this, i, a, c);
+      };
+    }), T(
+      s,
+      "removeEventListener",
+      function(o) {
+        return function(i, a, c) {
+          if (i === "click" || i == "keypress")
+            try {
+              const u = this.__sentry_instrumentation_handlers__ || {}, f = u[i];
+              f && (f.refCount--, f.refCount <= 0 && (o.call(this, i, f.handler, c), f.handler = void 0, delete u[i]), Object.keys(u).length === 0 && delete this.__sentry_instrumentation_handlers__);
+            } catch {
+            }
+          return o.call(this, i, a, c);
+        };
+      }
+    ));
+  });
+}
+function yi(t) {
+  if (t.type !== Ht)
+    return !1;
+  try {
+    if (!t.target || t.target._sentryId !== Gt)
+      return !1;
+  } catch {
+  }
+  return !0;
+}
+function Ei(t, e) {
+  return t !== "keypress" ? !1 : e?.tagName ? !(e.tagName === "INPUT" || e.tagName === "TEXTAREA" || e.isContentEditable) : !0;
+}
+function Xe(t, e = !1) {
+  return (n) => {
+    if (!n || n._sentryCaptured)
+      return;
+    const r = Si(n);
+    if (Ei(n.type, r))
+      return;
+    F(n, "_sentryCaptured", !0), r && !r._sentryId && F(r, "_sentryId", I());
+    const s = n.type === "keypress" ? "input" : n.type;
+    yi(n) || (t({ event: n, name: s, global: e }), Ht = n.type, Gt = r ? r._sentryId : void 0), clearTimeout(ze), ze = S.setTimeout(() => {
+      Gt = void 0, Ht = void 0;
+    }, mi);
+  };
+}
+function Si(t) {
+  try {
+    return t.target;
+  } catch {
+    return null;
+  }
+}
+let it;
+function jn(t) {
+  const e = "history";
+  j(e, t), B(e, bi);
+}
+function bi() {
+  if (S.addEventListener("popstate", () => {
+    const e = S.location.href, n = it;
+    if (it = e, n === e)
+      return;
+    v("history", { from: n, to: e });
+  }), !Wo())
+    return;
+  function t(e) {
+    return function(...n) {
+      const r = n.length > 2 ? n[2] : void 0;
+      if (r) {
+        const s = it, o = Ti(String(r));
+        if (it = o, s === o)
+          return e.apply(this, n);
+        v("history", { from: s, to: o });
+      }
+      return e.apply(this, n);
+    };
+  }
+  T(S.history, "pushState", t), T(S.history, "replaceState", t);
+}
+function Ti(t) {
+  try {
+    return new URL(t, S.location.origin).toString();
+  } catch {
+    return t;
+  }
+}
+const ft = {};
+function Ii(t) {
+  const e = ft[t];
+  if (e)
+    return e;
+  let n = S[t];
+  if ($t(n))
+    return ft[t] = n.bind(S);
+  const r = S.document;
+  if (r && typeof r.createElement == "function")
+    try {
+      const s = r.createElement("iframe");
+      s.hidden = !0, r.head.appendChild(s);
+      const o = s.contentWindow;
+      o?.[t] && (n = o[t]), r.head.removeChild(s);
+    } catch (s) {
+      hi && p.warn(`Could not create sandbox iframe for ${t} check, bailing to window.${t}: `, s);
+    }
+  return n && (ft[t] = n.bind(S));
+}
+function Ke(t) {
+  ft[t] = void 0;
+}
+const X = "__sentry_xhr_v3__";
+function vi(t) {
+  j("xhr", t), B("xhr", wi);
+}
+function wi() {
+  if (!S.XMLHttpRequest)
+    return;
+  const t = XMLHttpRequest.prototype;
+  t.open = new Proxy(t.open, {
+    apply(e, n, r) {
+      const s = new Error(), o = x() * 1e3, i = A(r[0]) ? r[0].toUpperCase() : void 0, a = Ri(r[1]);
+      if (!i || !a)
+        return e.apply(n, r);
+      n[X] = {
+        method: i,
+        url: a,
+        request_headers: {}
+      }, i === "POST" && a.match(/sentry_key/) && (n.__sentry_own_request__ = !0);
+      const c = () => {
+        const u = n[X];
+        if (u && n.readyState === 4) {
+          try {
+            u.status_code = n.status;
+          } catch {
+          }
+          const f = {
+            endTimestamp: x() * 1e3,
+            startTimestamp: o,
+            xhr: n,
+            virtualError: s
+          };
+          v("xhr", f);
+        }
+      };
+      return "onreadystatechange" in n && typeof n.onreadystatechange == "function" ? n.onreadystatechange = new Proxy(n.onreadystatechange, {
+        apply(u, f, l) {
+          return c(), u.apply(f, l);
+        }
+      }) : n.addEventListener("readystatechange", c), n.setRequestHeader = new Proxy(n.setRequestHeader, {
+        apply(u, f, l) {
+          const [m, d] = l, E = f[X];
+          return E && A(m) && A(d) && (E.request_headers[m.toLowerCase()] = d), u.apply(f, l);
+        }
+      }), e.apply(n, r);
+    }
+  }), t.send = new Proxy(t.send, {
+    apply(e, n, r) {
+      const s = n[X];
+      if (!s)
+        return e.apply(n, r);
+      r[0] !== void 0 && (s.body = r[0]);
+      const o = {
+        startTimestamp: x() * 1e3,
+        xhr: n
+      };
+      return v("xhr", o), e.apply(n, r);
+    }
+  });
+}
+function Ri(t) {
+  if (A(t))
+    return t;
+  try {
+    return t.toString();
+  } catch {
+  }
+}
+function ki(t, e = Ii("fetch")) {
+  let n = 0, r = 0;
+  function s(o) {
+    const i = o.body.length;
+    n += i, r++;
+    const a = {
+      body: o.body,
+      method: "POST",
+      referrerPolicy: "strict-origin",
+      headers: t.headers,
+      // Outgoing requests are usually cancelled when navigating to a different page, causing a "TypeError: Failed to
+      // fetch" error and sending a "network_error" client-outcome - in Chrome, the request status shows "(cancelled)".
+      // The `keepalive` flag keeps outgoing requests alive, even when switching pages. We want this since we're
+      // frequently sending events right before the user is switching pages (eg. when finishing navigation transactions).
+      // Gotchas:
+      // - `keepalive` isn't supported by Firefox
+      // - As per spec (https://fetch.spec.whatwg.org/#http-network-or-cache-fetch):
+      //   If the sum of contentLength and inflightKeepaliveBytes is greater than 64 kibibytes, then return a network error.
+      //   We will therefore only activate the flag when we're below that limit.
+      // There is also a limit of requests that can be open at the same time, so we also limit this to 15
+      // See https://github.com/getsentry/sentry-javascript/pull/7553 for details
+      keepalive: n <= 6e4 && r < 15,
+      ...t.fetchOptions
+    };
+    if (!e)
+      return Ke("fetch"), pt("No fetch implementation available");
+    try {
+      return e(t.url, a).then((c) => (n -= i, r--, {
+        statusCode: c.status,
+        headers: {
+          "x-sentry-rate-limits": c.headers.get("X-Sentry-Rate-Limits"),
+          "retry-after": c.headers.get("Retry-After")
+        }
+      }));
+    } catch (c) {
+      return Ke("fetch"), n -= i, r--, pt(c);
+    }
+  }
+  return mo(t, s);
+}
+const Ai = 30, xi = 50;
+function Wt(t, e, n, r) {
+  const s = {
+    filename: t,
+    function: e === "<anonymous>" ? M : e,
+    in_app: !0
+    // All browser frames are considered in_app
+  };
+  return n !== void 0 && (s.lineno = n), r !== void 0 && (s.colno = r), s;
+}
+const Oi = /^\s*at (\S+?)(?::(\d+))(?::(\d+))\s*$/i, Ni = /^\s*at (?:(.+?\)(?: \[.+\])?|.*?) ?\((?:address at )?)?(?:async )?((?:<anonymous>|[-a-z]+:|.*bundle|\/)?.*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i, Ci = /\((\S*)(?::(\d+))(?::(\d+))\)/, Di = (t) => {
+  const e = Oi.exec(t);
+  if (e) {
+    const [, r, s, o] = e;
+    return Wt(r, M, +s, +o);
+  }
+  const n = Ni.exec(t);
+  if (n) {
+    if (n[2] && n[2].indexOf("eval") === 0) {
+      const i = Ci.exec(n[2]);
+      i && (n[2] = i[1], n[3] = i[2], n[4] = i[3]);
+    }
+    const [s, o] = Bn(n[1] || M, n[2]);
+    return Wt(o, s, n[3] ? +n[3] : void 0, n[4] ? +n[4] : void 0);
+  }
+}, Li = [Ai, Di], Pi = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)?((?:[-a-z]+)?:\/.*?|\[native code\]|[^@]*(?:bundle|\d+\.js)|\/[\w\-. /=]+)(?::(\d+))?(?::(\d+))?\s*$/i, Mi = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i, Fi = (t) => {
+  const e = Pi.exec(t);
+  if (e) {
+    if (e[3] && e[3].indexOf(" > eval") > -1) {
+      const o = Mi.exec(e[3]);
+      o && (e[1] = e[1] || "eval", e[3] = o[1], e[4] = o[2], e[5] = "");
+    }
+    let r = e[3], s = e[1] || M;
+    return [s, r] = Bn(s, r), Wt(r, s, e[4] ? +e[4] : void 0, e[5] ? +e[5] : void 0);
+  }
+}, $i = [xi, Fi], Ui = [Li, $i], ji = sn(...Ui), Bn = (t, e) => {
+  const n = t.indexOf("safari-extension") !== -1, r = t.indexOf("safari-web-extension") !== -1;
+  return n || r ? [
+    t.indexOf("@") !== -1 ? t.split("@")[0] : M,
+    n ? `safari-extension:${e}` : `safari-web-extension:${e}`
+  ] : [t, e];
+}, bt = typeof __SENTRY_DEBUG__ > "u" || __SENTRY_DEBUG__, at = 1024, Bi = "Breadcrumbs", Hi = ((t = {}) => {
+  const e = {
+    console: !0,
+    dom: !0,
+    fetch: !0,
+    history: !0,
+    sentry: !0,
+    xhr: !0,
+    ...t
+  };
+  return {
+    name: Bi,
+    setup(n) {
+      e.console && Po(qi(n)), e.dom && gi(Wi(n, e.dom)), e.xhr && vi(Yi(n)), e.fetch && zo(zi(n)), e.history && jn(Xi(n)), e.sentry && n.on("beforeSendEvent", Gi(n));
+    }
+  };
+}), Hn = Hi;
+function Gi(t) {
+  return function(n) {
+    b() === t && U(
+      {
+        category: `sentry.${n.type === "transaction" ? "transaction" : "event"}`,
+        event_id: n.event_id,
+        level: n.level,
+        message: L(n)
+      },
+      {
+        event: n
+      }
+    );
+  };
+}
+function Wi(t, e) {
+  return function(r) {
+    if (b() !== t)
+      return;
+    let s, o, i = typeof e == "object" ? e.serializeAttribute : void 0, a = typeof e == "object" && typeof e.maxStringLength == "number" ? e.maxStringLength : void 0;
+    a && a > at && (bt && p.warn(
+      `\`dom.maxStringLength\` cannot exceed ${at}, but a value of ${a} was configured. Sentry will use ${at} instead.`
+    ), a = at), typeof i == "string" && (i = [i]);
+    try {
+      const u = r.event, f = Ki(u) ? u.target : u;
+      s = un(f, { keyAttrs: i, maxStringLength: a }), o = pr(f);
+    } catch {
+      s = "<unknown>";
+    }
+    if (s.length === 0)
+      return;
+    const c = {
+      category: `ui.${r.name}`,
+      message: s
+    };
+    o && (c.data = { "ui.component_name": o }), U(c, {
+      event: r.event,
+      name: r.name,
+      global: r.global
+    });
+  };
+}
+function qi(t) {
+  return function(n) {
+    if (b() !== t)
+      return;
+    const r = {
+      category: "console",
+      data: {
+        arguments: n.args,
+        logger: "console"
+      },
+      level: Fo(n.level),
+      message: de(n.args, " ")
+    };
+    if (n.level === "assert")
+      if (n.args[0] === !1)
+        r.message = `Assertion failed: ${de(n.args.slice(1), " ") || "console.assert"}`, r.data.arguments = n.args.slice(1);
+      else
+        return;
+    U(r, {
+      input: n.args,
+      level: n.level
+    });
+  };
+}
+function Yi(t) {
+  return function(n) {
+    if (b() !== t)
+      return;
+    const { startTimestamp: r, endTimestamp: s } = n, o = n.xhr[X];
+    if (!r || !s || !o)
+      return;
+    const { method: i, url: a, status_code: c, body: u } = o, f = {
+      method: i,
+      url: a,
+      status_code: c
+    }, l = {
+      xhr: n.xhr,
+      input: u,
+      startTimestamp: r,
+      endTimestamp: s
+    }, m = {
+      category: "xhr",
+      data: f,
+      type: "http",
+      level: Fn(c)
+    };
+    t.emit("beforeOutgoingRequestBreadcrumb", m, l), U(m, l);
+  };
+}
+function zi(t) {
+  return function(n) {
+    if (b() !== t)
+      return;
+    const { startTimestamp: r, endTimestamp: s } = n;
+    if (s && !(n.fetchData.url.match(/sentry_key/) && n.fetchData.method === "POST"))
+      if (n.fetchData.method, n.fetchData.url, n.error) {
+        const o = n.fetchData, i = {
+          data: n.error,
+          input: n.args,
+          startTimestamp: r,
+          endTimestamp: s
+        }, a = {
+          category: "fetch",
+          data: o,
+          level: "error",
+          type: "http"
+        };
+        t.emit("beforeOutgoingRequestBreadcrumb", a, i), U(a, i);
+      } else {
+        const o = n.response, i = {
+          ...n.fetchData,
+          status_code: o?.status
+        };
+        n.fetchData.request_body_size, n.fetchData.response_body_size, o?.status;
+        const a = {
+          input: n.args,
+          response: o,
+          startTimestamp: r,
+          endTimestamp: s
+        }, c = {
+          category: "fetch",
+          data: i,
+          type: "http",
+          level: Fn(i.status_code)
+        };
+        t.emit("beforeOutgoingRequestBreadcrumb", c, a), U(c, a);
+      }
+  };
+}
+function Xi(t) {
+  return function(n) {
+    if (b() !== t)
+      return;
+    let r = n.from, s = n.to;
+    const o = xt(y.location.href);
+    let i = r ? xt(r) : void 0;
+    const a = xt(s);
+    i?.path || (i = o), o.protocol === a.protocol && o.host === a.host && (s = a.relative), o.protocol === i.protocol && o.host === i.host && (r = i.relative), U({
+      category: "navigation",
+      data: {
+        from: r,
+        to: s
+      }
+    });
+  };
+}
+function Ki(t) {
+  return !!t && !!t.target;
+}
+const Vi = [
+  "EventTarget",
+  "Window",
+  "Node",
+  "ApplicationCache",
+  "AudioTrackList",
+  "BroadcastChannel",
+  "ChannelMergerNode",
+  "CryptoOperation",
+  "EventSource",
+  "FileReader",
+  "HTMLUnknownElement",
+  "IDBDatabase",
+  "IDBRequest",
+  "IDBTransaction",
+  "KeyOperation",
+  "MediaController",
+  "MessagePort",
+  "ModalWindow",
+  "Notification",
+  "SVGElementInstance",
+  "Screen",
+  "SharedWorker",
+  "TextTrack",
+  "TextTrackCue",
+  "TextTrackList",
+  "WebSocket",
+  "WebSocketWorker",
+  "Worker",
+  "XMLHttpRequest",
+  "XMLHttpRequestEventTarget",
+  "XMLHttpRequestUpload"
+], Ji = "BrowserApiErrors", Zi = ((t = {}) => {
+  const e = {
+    XMLHttpRequest: !0,
+    eventTarget: !0,
+    requestAnimationFrame: !0,
+    setInterval: !0,
+    setTimeout: !0,
+    unregisterOriginalCallbacks: !1,
+    ...t
+  };
+  return {
+    name: Ji,
+    // TODO: This currently only works for the first client this is setup
+    // We may want to adjust this to check for client etc.
+    setupOnce() {
+      e.setTimeout && T(y, "setTimeout", Ve), e.setInterval && T(y, "setInterval", Ve), e.requestAnimationFrame && T(y, "requestAnimationFrame", ta), e.XMLHttpRequest && "XMLHttpRequest" in y && T(XMLHttpRequest.prototype, "send", ea);
+      const n = e.eventTarget;
+      n && (Array.isArray(n) ? n : Vi).forEach((s) => na(s, e));
+    }
+  };
+}), Qi = Zi;
+function Ve(t) {
+  return function(...e) {
+    const n = e[0];
+    return e[0] = q(n, {
+      mechanism: {
+        data: { function: O(t) },
+        handled: !1,
+        type: "instrument"
+      }
+    }), t.apply(this, e);
+  };
+}
+function ta(t) {
+  return function(e) {
+    return t.apply(this, [
+      q(e, {
+        mechanism: {
+          data: {
+            function: "requestAnimationFrame",
+            handler: O(t)
+          },
+          handled: !1,
+          type: "instrument"
+        }
+      })
+    ]);
+  };
+}
+function ea(t) {
+  return function(...e) {
+    const n = this;
+    return ["onload", "onerror", "onprogress", "onreadystatechange"].forEach((s) => {
+      s in n && typeof n[s] == "function" && T(n, s, function(o) {
+        const i = {
+          mechanism: {
+            data: {
+              function: s,
+              handler: O(o)
+            },
+            handled: !1,
+            type: "instrument"
+          }
+        }, a = Zt(o);
+        return a && (i.mechanism.data.handler = O(a)), q(o, i);
+      });
+    }), t.apply(this, e);
+  };
+}
+function na(t, e) {
+  const r = y[t]?.prototype;
+  r?.hasOwnProperty?.("addEventListener") && (T(r, "addEventListener", function(s) {
+    return function(o, i, a) {
+      try {
+        ra(i) && (i.handleEvent = q(i.handleEvent, {
+          mechanism: {
+            data: {
+              function: "handleEvent",
+              handler: O(i),
+              target: t
+            },
+            handled: !1,
+            type: "instrument"
+          }
+        }));
+      } catch {
+      }
+      return e.unregisterOriginalCallbacks && sa(this, o, i), s.apply(this, [
+        o,
+        q(i, {
+          mechanism: {
+            data: {
+              function: "addEventListener",
+              handler: O(i),
+              target: t
+            },
+            handled: !1,
+            type: "instrument"
+          }
+        }),
+        a
+      ]);
+    };
+  }), T(r, "removeEventListener", function(s) {
+    return function(o, i, a) {
+      try {
+        const c = i.__sentry_wrapped__;
+        c && s.call(this, o, c, a);
+      } catch {
+      }
+      return s.call(this, o, i, a);
+    };
+  }));
+}
+function ra(t) {
+  return typeof t.handleEvent == "function";
+}
+function sa(t, e, n) {
+  t && typeof t == "object" && "removeEventListener" in t && typeof t.removeEventListener == "function" && t.removeEventListener(e, n);
+}
+const oa = () => ({
+  name: "BrowserSession",
+  setupOnce() {
+    if (typeof y.document > "u") {
+      bt && p.warn("Using the `browserSessionIntegration` in non-browser environments is not supported.");
+      return;
+    }
+    Ce({ ignoreDuration: !0 }), De(), jn(({ from: t, to: e }) => {
+      t !== void 0 && t !== e && (Ce({ ignoreDuration: !0 }), De());
+    });
+  }
+}), ia = "GlobalHandlers", aa = ((t = {}) => {
+  const e = {
+    onerror: !0,
+    onunhandledrejection: !0,
+    ...t
+  };
+  return {
+    name: ia,
+    setupOnce() {
+      Error.stackTraceLimit = 50;
+    },
+    setup(n) {
+      e.onerror && (ua(n), Je("onerror")), e.onunhandledrejection && (fa(n), Je("onunhandledrejection"));
+    }
+  };
+}), ca = aa;
+function ua(t) {
+  nr((e) => {
+    const { stackParser: n, attachStacktrace: r } = Gn();
+    if (b() !== t || $n())
+      return;
+    const { msg: s, url: o, line: i, column: a, error: c } = e, u = pa(
+      se(n, c || s, void 0, r, !1),
+      o,
+      i,
+      a
+    );
+    u.level = "error", wn(u, {
+      originalException: c,
+      mechanism: {
+        handled: !1,
+        type: "onerror"
+      }
+    });
+  });
+}
+function fa(t) {
+  sr((e) => {
+    const { stackParser: n, attachStacktrace: r } = Gn();
+    if (b() !== t || $n())
+      return;
+    const s = la(e), o = Kt(s) ? da(s) : se(n, s, void 0, r, !0);
+    o.level = "error", wn(o, {
+      originalException: s,
+      mechanism: {
+        handled: !1,
+        type: "onunhandledrejection"
+      }
+    });
+  });
+}
+function la(t) {
+  if (Kt(t))
+    return t;
+  try {
+    if ("reason" in t)
+      return t.reason;
+    if ("detail" in t && "reason" in t.detail)
+      return t.detail.reason;
+  } catch {
+  }
+  return t;
+}
+function da(t) {
+  return {
+    exception: {
+      values: [
+        {
+          type: "UnhandledRejection",
+          // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)
+          value: `Non-Error promise rejection captured with value: ${String(t)}`
+        }
+      ]
+    }
+  };
+}
+function pa(t, e, n, r) {
+  const s = t.exception = t.exception || {}, o = s.values = s.values || [], i = o[0] = o[0] || {}, a = i.stacktrace = i.stacktrace || {}, c = a.frames = a.frames || [], u = r, f = n, l = A(e) && e.length > 0 ? e : Jt();
+  return c.length === 0 && c.push({
+    colno: u,
+    filename: l,
+    function: M,
+    in_app: !0,
+    lineno: f
+  }), t;
+}
+function Je(t) {
+  bt && p.log(`Global Handler attached: ${t}`);
+}
+function Gn() {
+  return b()?.getOptions() || {
+    stackParser: () => [],
+    attachStacktrace: !1
+  };
+}
+const ha = () => ({
+  name: "HttpContext",
+  preprocessEvent(t) {
+    if (!y.navigator && !y.location && !y.document)
+      return;
+    const e = Qo(), n = {
+      ...e.headers,
+      ...t.request?.headers
+    };
+    t.request = {
+      ...e,
+      ...t.request,
+      headers: n
+    };
+  }
+}), ma = "cause", ga = 5, _a = "LinkedErrors", ya = ((t = {}) => {
+  const e = t.limit || ga, n = t.key || ma;
+  return {
+    name: _a,
+    preprocessEvent(r, s, o) {
+      const i = o.getOptions();
+      Lo(
+        // This differs from the LinkedErrors integration in core by using a different exceptionFromError function
+        ne,
+        i.stackParser,
+        n,
+        e,
+        r,
+        s
+      );
+    }
+  };
+}), Ea = ya;
+function Sa() {
+  return ba() ? (bt && Y(() => {
+    console.error(
+      "[Sentry] You cannot use Sentry.init() in a browser extension, see: https://docs.sentry.io/platforms/javascript/best-practices/browser-extensions/"
+    );
+  }), !0) : !1;
+}
+function ba() {
+  if (typeof y.window > "u")
+    return !1;
+  const t = y;
+  if (t.nw || !(t.chrome || t.browser)?.runtime?.id)
+    return !1;
+  const n = Jt(), r = ["chrome-extension", "moz-extension", "ms-browser-extension", "safari-web-extension"];
+  return !(y === y.top && r.some((o) => n.startsWith(`${o}://`)));
+}
+function Ta(t) {
+  return [
+    // TODO(v10): Replace with `eventFiltersIntegration` once we remove the deprecated `inboundFiltersIntegration`
+    // eslint-disable-next-line deprecation/deprecation
+    Ro(),
+    To(),
+    Qi(),
+    Hn(),
+    ca(),
+    Ea(),
+    jo(),
+    ha(),
+    oa()
+  ];
+}
+function Ia(t = {}) {
+  const e = !t.skipBrowserExtensionCheck && Sa(), n = {
+    ...t,
+    enabled: e ? !1 : t.enabled,
+    stackParser: tr(t.stackParser || ji),
+    integrations: Xs({
+      integrations: t.integrations,
+      defaultIntegrations: t.defaultIntegrations == null ? Ta() : t.defaultIntegrations
+    }),
+    transport: t.transport || ki
+  };
+  return oo(di, n);
+}
+const va = "https://005d25250a41bd0071570b0c0a2b2c4d@o4510467570073600.ingest.us.sentry.io/4510472944156672";
+let Ze = !1;
+function Da() {
+  Ze || (Ia({
+    dsn: va,
+    // Only capture errors, not performance data.
+    tracesSampleRate: 0,
+    // Minimal breadcrumbs to reduce noise.
+    integrations: [
+      Hn({
+        console: !1,
+        dom: !0,
+        fetch: !0,
+        history: !1,
+        xhr: !1
+      })
+    ],
+    // Tag all events as coming from the widget.
+    initialScope: {
+      tags: {
+        source: "knest-widget"
+      }
+    }
+  }), Ze = !0);
+}
+function La(t, e) {
+  const n = typeof t == "string" ? new Error(t) : t;
+  vn(n, {
+    tags: { source: "knest-widget" },
+    extra: e
+  });
+}
 export {
-  g as API_BASE_URL,
-  y as CHAT_API_URL,
-  m as CONFIG_API_URL,
-  R as DEFAULT_AVATAR_URL,
-  S as DEFAULT_BRAND_COLOR,
-  u as DEFAULT_ERROR_MESSAGE,
-  C as DEFAULT_EXAMPLE_QUESTIONS,
-  L as DEFAULT_WELCOME_MESSAGE,
-  I as FALLBACK_ERROR_MESSAGE,
-  T as fetchWidgetConfig,
-  O as formatContent,
-  b as streamChatMessage
+  en as API_PATH,
+  Ra as DEFAULT_AVATAR_URL,
+  tn as DEFAULT_BASE_URL,
+  ka as DEFAULT_BRAND_COLOR,
+  ie as DEFAULT_ERROR_MESSAGE,
+  xa as DEFAULT_EXAMPLE_QUESTIONS,
+  Aa as DEFAULT_WELCOME_MESSAGE,
+  Yn as FALLBACK_ERROR_MESSAGE,
+  La as captureWidgetException,
+  Oa as fetchWidgetConfig,
+  Ca as formatContent,
+  Wn as getChatApiUrl,
+  qn as getConfigApiUrl,
+  Da as initWidgetSentry,
+  Na as streamChatMessage
 };