@eloquentai/chat-sdk 0.33.10-dev → 0.33.12-dev

package/dist/index-hFbiYJI3.js

@@ -0,0 +1,4165 @@
+import { version as $n } from "react";
+try {
+  let t = typeof window < "u" ? window : typeof global < "u" ? global : typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : {}, e = new t.Error().stack;
+  e && (t._sentryDebugIds = t._sentryDebugIds || {}, t._sentryDebugIds[e] = "e9e07d9e-81ff-4000-8e62-1fc2f7e9504f", t._sentryDebugIdIdentifier = "sentry-dbid-e9e07d9e-81ff-4000-8e62-1fc2f7e9504f");
+} catch {
+}
+const h = typeof __SENTRY_DEBUG__ > "u" || __SENTRY_DEBUG__, g = globalThis, L = "9.47.1";
+function mt() {
+  return gt(g), g;
+}
+function gt(t) {
+  const e = t.__SENTRY__ = t.__SENTRY__ || {};
+  return e.version = e.version || L, e[L] = e[L] || {};
+}
+function Z(t, e, n = g) {
+  const r = n.__SENTRY__ = n.__SENTRY__ || {}, s = r[L] = r[L] || {};
+  return s[t] || (s[t] = e());
+}
+const Un = [
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "log",
+  "assert",
+  "trace"
+], jn = "Sentry Logger ", lt = {};
+function q(t) {
+  if (!("console" in g))
+    return t();
+  const e = g.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 Bn() {
+  Yt().enabled = !0;
+}
+function Hn() {
+  Yt().enabled = !1;
+}
+function Je() {
+  return Yt().enabled;
+}
+function Gn(...t) {
+  qt("log", ...t);
+}
+function Wn(...t) {
+  qt("warn", ...t);
+}
+function qn(...t) {
+  qt("error", ...t);
+}
+function qt(t, ...e) {
+  h && Je() && q(() => {
+    g.console[t](`${jn}[${t}]:`, ...e);
+  });
+}
+function Yt() {
+  return h ? Z("loggerSettings", () => ({ enabled: !1 })) : { enabled: !1 };
+}
+const p = {
+  /** Enable logging. */
+  enable: Bn,
+  /** Disable logging. */
+  disable: Hn,
+  /** Check if logging is enabled. */
+  isEnabled: Je,
+  /** Log a message. */
+  log: Gn,
+  /** Log a warning. */
+  warn: Wn,
+  /** Log an error. */
+  error: qn
+}, Ze = 50, P = "?", ie = /\(error: (.*)\)/, ae = /captureMessage|captureException/;
+function Qe(...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 = ie.test(c) ? c.replace(ie, "$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 >= Ze + s)
+          break;
+      }
+    }
+    return zn(o.slice(s));
+  };
+}
+function Yn(t) {
+  return Array.isArray(t) ? Qe(...t) : t;
+}
+function zn(t) {
+  if (!t.length)
+    return [];
+  const e = Array.from(t);
+  return /sentryWrapped/.test(nt(e).function || "") && e.pop(), e.reverse(), ae.test(nt(e).function || "") && (e.pop(), ae.test(nt(e).function || "") && e.pop()), e.slice(0, Ze).map((n) => ({
+    ...n,
+    filename: n.filename || nt(e).filename,
+    function: n.function || P
+  }));
+}
+function nt(t) {
+  return t[t.length - 1] || {};
+}
+const It = "<anonymous>";
+function x(t) {
+  try {
+    return !t || typeof t != "function" ? It : t.name || It;
+  } catch {
+    return It;
+  }
+}
+function ce(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 = {}, ue = {};
+function U(t, e) {
+  ct[t] = ct[t] || [], ct[t].push(e);
+}
+function j(t, e) {
+  if (!ue[t]) {
+    ue[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: ${x(r)}
+Error:`,
+          s
+        );
+      }
+}
+let vt = null;
+function Xn(t) {
+  const e = "error";
+  U(e, t), j(e, Vn);
+}
+function Vn() {
+  vt = g.onerror, g.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;
+  }, g.onerror.__SENTRY_INSTRUMENTED__ = !0;
+}
+let kt = null;
+function Kn(t) {
+  const e = "unhandledrejection";
+  U(e, t), j(e, Jn);
+}
+function Jn() {
+  kt = g.onunhandledrejection, g.onunhandledrejection = function(t) {
+    return v("unhandledrejection", t), kt ? kt.apply(this, arguments) : !0;
+  }, g.onunhandledrejection.__SENTRY_INSTRUMENTED__ = !0;
+}
+const tn = Object.prototype.toString;
+function zt(t) {
+  switch (tn.call(t)) {
+    case "[object Error]":
+    case "[object Exception]":
+    case "[object DOMException]":
+    case "[object WebAssembly.Exception]":
+      return !0;
+    default:
+      return O(t, Error);
+  }
+}
+function Y(t, e) {
+  return tn.call(t) === `[object ${e}]`;
+}
+function en(t) {
+  return Y(t, "ErrorEvent");
+}
+function fe(t) {
+  return Y(t, "DOMError");
+}
+function Zn(t) {
+  return Y(t, "DOMException");
+}
+function w(t) {
+  return Y(t, "String");
+}
+function Xt(t) {
+  return typeof t == "object" && t !== null && "__sentry_template_string__" in t && "__sentry_template_values__" in t;
+}
+function Vt(t) {
+  return t === null || Xt(t) || typeof t != "object" && typeof t != "function";
+}
+function K(t) {
+  return Y(t, "Object");
+}
+function _t(t) {
+  return typeof Event < "u" && O(t, Event);
+}
+function Qn(t) {
+  return typeof Element < "u" && O(t, Element);
+}
+function tr(t) {
+  return Y(t, "RegExp");
+}
+function yt(t) {
+  return !!(t?.then && typeof t.then == "function");
+}
+function er(t) {
+  return K(t) && "nativeEvent" in t && "preventDefault" in t && "stopPropagation" in t;
+}
+function O(t, e) {
+  try {
+    return t instanceof e;
+  } catch {
+    return !1;
+  }
+}
+function nn(t) {
+  return !!(typeof t == "object" && t !== null && (t.__isVue || t._isVue));
+}
+function nr(t) {
+  return typeof Request < "u" && O(t, Request);
+}
+const Kt = g, rr = 80;
+function rn(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 || rr;
+    for (; n && o++ < r && (u = sr(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 sr(t, e) {
+  const n = t, r = [];
+  if (!n?.tagName)
+    return "";
+  if (Kt.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 && w(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 Kt.document.location.href;
+  } catch {
+    return "";
+  }
+}
+function or(t) {
+  if (!Kt.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 le(t, e) {
+  if (!Array.isArray(t))
+    return "";
+  const n = [];
+  for (let r = 0; r < t.length; r++) {
+    const s = t[r];
+    try {
+      nn(s) ? n.push("[VueViewModel]") : n.push(String(s));
+    } catch {
+      n.push("[value cannot be serialized]");
+    }
+  }
+  return n.join(e);
+}
+function ir(t, e, n = !1) {
+  return w(t) ? tr(e) ? e.test(t) : w(e) ? n ? t === e : t.includes(e) : !1 : !1;
+}
+function Et(t, e = [], n = !1) {
+  return e.some((r) => ir(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" && sn(s, r);
+  try {
+    t[e] = s;
+  } catch {
+    h && p.log(`Failed to replace method "${e}" in object`, t);
+  }
+}
+function M(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 sn(t, e) {
+  try {
+    const n = e.prototype || {};
+    t.prototype = e.prototype = n, M(t, "__sentry_original__", e);
+  } catch {
+  }
+}
+function Zt(t) {
+  return t.__sentry_original__;
+}
+function on(t) {
+  if (zt(t))
+    return {
+      message: t.message,
+      name: t.name,
+      stack: t.stack,
+      ...pe(t)
+    };
+  if (_t(t)) {
+    const e = {
+      type: t.type,
+      target: de(t.target),
+      currentTarget: de(t.currentTarget),
+      ...pe(t)
+    };
+    return typeof CustomEvent < "u" && O(t, CustomEvent) && (e.detail = t.detail), e;
+  } else
+    return t;
+}
+function de(t) {
+  try {
+    return Qn(t) ? rn(t) : Object.prototype.toString.call(t);
+  } catch {
+    return "<unknown>";
+  }
+}
+function pe(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 ar(t, e = 40) {
+  const n = Object.keys(on(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 cr() {
+  const t = g;
+  return t.crypto || t.msCrypto;
+}
+function I(t = cr()) {
+  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 an(t) {
+  return t.exception?.values?.[0];
+}
+function C(t) {
+  const { message: e, event_id: n } = t;
+  if (e)
+    return e;
+  const r = an(t);
+  return r ? r.type && r.value ? `${r.type}: ${r.value}` : r.type || r.value || n || "<unknown>" : n || "<unknown>";
+}
+function Dt(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 B(t, e) {
+  const n = an(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 he(t) {
+  if (ur(t))
+    return !0;
+  try {
+    M(t, "__sentry_captured__", !0);
+  } catch {
+  }
+  return !1;
+}
+function ur(t) {
+  try {
+    return t.__sentry_captured__;
+  } catch {
+  }
+}
+const cn = 1e3;
+function Q() {
+  return Date.now() / cn;
+}
+function fr() {
+  const { performance: t } = g;
+  if (!t?.now || !t.timeOrigin)
+    return Q;
+  const e = t.timeOrigin;
+  return () => (e + t.now()) / cn;
+}
+let me;
+function R() {
+  return (me ?? (me = fr()))();
+}
+function lr(t) {
+  const e = R(), n = {
+    sid: I(),
+    init: !0,
+    timestamp: e,
+    started: e,
+    duration: 0,
+    status: "ok",
+    errors: 0,
+    ignoreDuration: !1,
+    toJSON: () => pr(n)
+  };
+  return t && H(n, t), n;
+}
+function H(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 || R(), 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 dr(t, e) {
+  let n = {};
+  t.status === "ok" && (n = { status: "exited" }), H(t, n);
+}
+function pr(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 tt(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] = tt(r[s], e[s], n - 1));
+  return r;
+}
+function ge() {
+  return I();
+}
+function un() {
+  return I().substring(16);
+}
+const At = "_sentrySpan";
+function _e(t, e) {
+  e ? M(t, At, e) : delete t[At];
+}
+function ye(t) {
+  return t[At];
+}
+const hr = 100;
+class N {
+  /** 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: ge(),
+      sampleRand: Math.random()
+    };
+  }
+  /**
+   * Clone all data from this scope into a new scope.
+   */
+  clone() {
+    const e = new N();
+    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, _e(e, ye(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 && H(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 N ? 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, _e(this, void 0), this._attachments = [], this.setPropagationContext({ traceId: ge(), 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 : hr;
+    if (r <= 0)
+      return this;
+    const s = {
+      timestamp: Q(),
+      ...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: ye(this)
+    };
+  }
+  /**
+   * Add data which will be accessible during event processing but won't get sent to Sentry.
+   */
+  setSDKProcessingMetadata(e) {
+    return this._sdkProcessingMetadata = tt(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 mr() {
+  return Z("defaultCurrentScope", () => new N());
+}
+function gr() {
+  return Z("defaultIsolationScope", () => new N());
+}
+class _r {
+  constructor(e, n) {
+    let r;
+    e ? r = e : r = new N();
+    let s;
+    n ? s = n : s = new N(), 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 G() {
+  const t = mt(), e = gt(t);
+  return e.stack = e.stack || new _r(mr(), gr());
+}
+function yr(t) {
+  return G().withScope(t);
+}
+function Er(t, e) {
+  const n = G();
+  return n.withScope(() => (n.getStackTop().scope = t, e(t)));
+}
+function Ee(t) {
+  return G().withScope(() => t(G().getIsolationScope()));
+}
+function Sr() {
+  return {
+    withIsolationScope: Ee,
+    withScope: yr,
+    withSetScope: Er,
+    withSetIsolationScope: (t, e) => Ee(e),
+    getCurrentScope: () => G().getScope(),
+    getIsolationScope: () => G().getIsolationScope()
+  };
+}
+function Qt(t) {
+  const e = gt(t);
+  return e.acs ? e.acs : Sr();
+}
+function A() {
+  const t = mt();
+  return Qt(t).getCurrentScope();
+}
+function z() {
+  const t = mt();
+  return Qt(t).getIsolationScope();
+}
+function br() {
+  return Z("globalScope", () => new N());
+}
+function Tr(...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 A().getClient();
+}
+function Ir(t) {
+  const e = t.getPropagationContext(), { traceId: n, parentSpanId: r, propagationSpanId: s } = e, o = {
+    trace_id: n,
+    span_id: s || un()
+  };
+  return r && (o.parent_span_id = r), o;
+}
+const vr = "sentry.source", kr = "sentry.sample_rate", wr = "sentry.previous_trace_sample_rate", Rr = "sentry.op", Nr = "sentry.origin", fn = "sentry.profile_id", ln = "sentry.exclusive_time", xr = 0, Or = 1, Dr = "_sentryScope", Ar = "_sentryIsolationScope";
+function dn(t) {
+  return {
+    scope: t[Dr],
+    isolationScope: t[Ar]
+  };
+}
+const Cr = "sentry-", Lr = /^sentry-/;
+function Pr(t) {
+  const e = Mr(t);
+  if (!e)
+    return;
+  const n = Object.entries(e).reduce((r, [s, o]) => {
+    if (s.match(Lr)) {
+      const i = s.slice(Cr.length);
+      r[i] = o;
+    }
+    return r;
+  }, {});
+  if (Object.keys(n).length > 0)
+    return n;
+}
+function Mr(t) {
+  if (!(!t || !w(t) && !Array.isArray(t)))
+    return Array.isArray(t) ? t.reduce((e, n) => {
+      const r = Se(n);
+      return Object.entries(r).forEach(([s, o]) => {
+        e[s] = o;
+      }), e;
+    }, {}) : Se(t);
+}
+function Se(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 Fr(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 pn = 1;
+let be = !1;
+function $r(t) {
+  const { spanId: e, traceId: n, isRemote: r } = t.spanContext(), s = r ? e : te(t).parent_span_id, o = dn(t).scope, i = r ? o?.getPropagationContext().propagationSpanId || un() : e;
+  return {
+    parent_span_id: s,
+    span_id: i,
+    trace_id: n
+  };
+}
+function Ur(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 === pn,
+      attributes: o,
+      ...s
+    }));
+}
+function Te(t) {
+  return typeof t == "number" ? Ie(t) : Array.isArray(t) ? t[0] + t[1] / 1e9 : t instanceof Date ? Ie(t.getTime()) : R();
+}
+function Ie(t) {
+  return t > 9999999999 ? t / 1e3 : t;
+}
+function te(t) {
+  if (Br(t))
+    return t.getSpanJSON();
+  const { spanId: e, traceId: n } = t.spanContext();
+  if (jr(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: Te(s),
+      // This is [0,0] by default in OTEL, in which case we want to interpret this as no end time
+      timestamp: Te(i) || void 0,
+      status: Gr(a),
+      op: r[Rr],
+      origin: r[Nr],
+      links: Ur(c)
+    };
+  }
+  return {
+    span_id: e,
+    trace_id: n,
+    start_timestamp: 0,
+    data: {}
+  };
+}
+function jr(t) {
+  const e = t;
+  return !!e.attributes && !!e.startTime && !!e.name && !!e.endTime && !!e.status;
+}
+function Br(t) {
+  return typeof t.getSpanJSON == "function";
+}
+function Hr(t) {
+  const { traceFlags: e } = t.spanContext();
+  return e === pn;
+}
+function Gr(t) {
+  if (!(!t || t.code === xr))
+    return t.code === Or ? "ok" : t.message || "unknown_error";
+}
+const Wr = "_sentryRootSpan";
+function hn(t) {
+  return t[Wr] || t;
+}
+function ve() {
+  be || (q(() => {
+    console.warn(
+      "[Sentry] Returning null from `beforeSendSpan` is disallowed. To drop certain spans, configure the respective integrations directly."
+    );
+  }), be = !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", Yr = /^o(\d+)\./, zr = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+)?)?@)([\w.-]+)(?::(\d+))?\/(.+)/;
+function Xr(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 Vr(t) {
+  const e = zr.exec(t);
+  if (!e) {
+    q(() => {
+      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 mn({ host: o, pass: s, path: c, projectId: u, port: i, protocol: n, publicKey: r });
+}
+function mn(t) {
+  return {
+    protocol: t.protocol,
+    publicKey: t.publicKey || "",
+    pass: t.pass || "",
+    host: t.host,
+    port: t.port || "",
+    path: t.path || "",
+    projectId: t.projectId
+  };
+}
+function Kr(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+$/) ? Xr(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 Jr(t) {
+  return t.match(Yr)?.[1];
+}
+function Zr(t) {
+  const e = typeof t == "string" ? Vr(t) : mn(t);
+  if (!(!e || !Kr(e)))
+    return e;
+}
+const Qr = "_frozenDsc";
+function gn(t, e) {
+  const n = e.getOptions(), { publicKey: r, host: s } = e.getDsn() || {};
+  let o;
+  n.orgId ? o = String(n.orgId) : s && (o = Jr(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 ts(t, e) {
+  const n = e.getPropagationContext();
+  return n.dsc || gn(n.traceId, t);
+}
+function es(t) {
+  const e = b();
+  if (!e)
+    return {};
+  const n = hn(t), r = te(n), s = r.data, o = n.spanContext().traceState, i = o?.get("sentry.sample_rate") ?? s[kr] ?? s[wr];
+  function a(y) {
+    return (typeof i == "number" || typeof i == "string") && (y.sample_rate = `${i}`), y;
+  }
+  const c = n[Qr];
+  if (c)
+    return a(c);
+  const u = o?.get("sentry.dsc"), f = u && Pr(u);
+  if (f)
+    return a(f);
+  const l = gn(t.spanContext().traceId, e), m = s[vr], d = r.description;
+  return m !== "url" && d && (l.transaction = d), qr() && (l.sampled = String(Hr(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)
+  dn(n).scope?.getPropagationContext().sampleRand.toString()), a(l), e.emit("createDsc", l, n), l;
+}
+function k(t, e = 100, n = 1 / 0) {
+  try {
+    return Ct("", t, e, n);
+  } catch (r) {
+    return { ERROR: `**non-serializable** (${r})` };
+  }
+}
+function _n(t, e = 3, n = 100 * 1024) {
+  const r = k(t, e);
+  return os(r) > n ? _n(t, e - 1, n) : r;
+}
+function Ct(t, e, n = 1 / 0, r = 1 / 0, s = is()) {
+  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 = ns(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 Ct("", d, c - 1, r, s);
+    } catch {
+    }
+  const f = Array.isArray(e) ? [] : {};
+  let l = 0;
+  const m = on(e);
+  for (const d in m) {
+    if (!Object.prototype.hasOwnProperty.call(m, d))
+      continue;
+    if (l >= r) {
+      f[d] = "[MaxProperties ~]";
+      break;
+    }
+    const y = m[d];
+    f[d] = Ct(d, y, c - 1, r, s), l++;
+  }
+  return i(e), f;
+}
+function ns(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 (nn(e))
+      return "[VueViewModel]";
+    if (er(e))
+      return "[SyntheticEvent]";
+    if (typeof e == "number" && !Number.isFinite(e))
+      return `[${e}]`;
+    if (typeof e == "function")
+      return `[Function: ${x(e)}]`;
+    if (typeof e == "symbol")
+      return `[${String(e)}]`;
+    if (typeof e == "bigint")
+      return `[BigInt: ${String(e)}]`;
+    const n = rs(e);
+    return /^HTML(\w*)Element$/.test(n) ? `[HTMLElement: ${n}]` : `[object ${n}]`;
+  } catch (n) {
+    return `**non-serializable** (${n})`;
+  }
+}
+function rs(t) {
+  const e = Object.getPrototypeOf(t);
+  return e?.constructor ? e.constructor.name : "null prototype";
+}
+function ss(t) {
+  return ~-encodeURI(t).split(/%..|./).length;
+}
+function os(t) {
+  return ss(JSON.stringify(t));
+}
+function is() {
+  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 as(t, e) {
+  const [n, r] = t;
+  return [n, [...r, e]];
+}
+function ke(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(g);
+  return e.encodePolyfill ? e.encodePolyfill(t) : new TextEncoder().encode(t);
+}
+function cs(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 : us(r);
+}
+function us(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 fs(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 ls = {
+  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 we(t) {
+  return ls[t];
+}
+function yn(t) {
+  if (!t?.sdk)
+    return;
+  const { name: e, version: n } = t.sdk;
+  return { name: e, version: n };
+}
+function ds(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 ps(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 hs(t, e, n, r) {
+  const s = yn(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 ms(t, e, n, r) {
+  const s = yn(n), o = t.type && t.type !== "replay_event" ? t.type : "event";
+  ps(t, n?.sdk);
+  const i = ds(t, s, r, e);
+  return delete t.sdkProcessingMetadata, et(i, [[{ type: o }, t]]);
+}
+const wt = 0, Re = 1, Ne = 2;
+function F(t) {
+  return new D((e) => {
+    e(t);
+  });
+}
+function pt(t) {
+  return new D((e, n) => {
+    n(t);
+  });
+}
+class D {
+  constructor(e) {
+    this._state = wt, this._handlers = [], this._runExecutor(e);
+  }
+  /** @inheritdoc */
+  then(e, n) {
+    return new D((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 D((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 === wt)
+      return;
+    const e = this._handlers.slice();
+    this._handlers = [], e.forEach((n) => {
+      n[0] || (this._state === Re && n[1](this._value), this._state === Ne && n[2](this._value), n[0] = !0);
+    });
+  }
+  /** Run the executor for the SyncPromise. */
+  _runExecutor(e) {
+    const n = (o, i) => {
+      if (this._state === wt) {
+        if (yt(i)) {
+          i.then(r, s);
+          return;
+        }
+        this._state = o, this._value = i, this._executeHandlers();
+      }
+    }, r = (o) => {
+      n(Re, o);
+    }, s = (o) => {
+      n(Ne, o);
+    };
+    try {
+      e(r, s);
+    } catch (o) {
+      s(o);
+    }
+  }
+}
+function Pt(t, e, n, r = 0) {
+  return new D((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 gs(t, e) {
+  const { fingerprint: n, span: r, breadcrumbs: s, sdkProcessingMetadata: o } = e;
+  _s(t, e), r && Ss(t, r), bs(t, n), ys(t, s), Es(t, o);
+}
+function xe(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: y
+  } = e;
+  rt(t, "extra", n), rt(t, "tags", r), rt(t, "user", s), rt(t, "contexts", o), t.sdkProcessingMetadata = tt(t.sdkProcessingMetadata, a, 2), i && (t.level = i), d && (t.transactionName = d), y && (t.span = y), 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] = tt(t[e], n, 1);
+}
+function _s(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 ys(t, e) {
+  const n = [...t.breadcrumbs || [], ...e];
+  t.breadcrumbs = n.length ? n : void 0;
+}
+function Es(t, e) {
+  t.sdkProcessingMetadata = {
+    ...t.sdkProcessingMetadata,
+    ...e
+  };
+}
+function Ss(t, e) {
+  t.contexts = {
+    trace: $r(e),
+    ...t.contexts
+  }, t.sdkProcessingMetadata = {
+    dynamicSamplingContext: es(e),
+    ...t.sdkProcessingMetadata
+  };
+  const n = hn(e), r = te(n).description;
+  r && !t.transaction && t.type === "transaction" && (t.transaction = r);
+}
+function bs(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, Oe, ot;
+function Ts(t) {
+  const e = g._sentryDebugIds;
+  if (!e)
+    return {};
+  const n = Object.keys(e);
+  return ot && n.length === Oe || (Oe = 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 Is(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 || Q()
+  }, u = n.integrations || t.integrations.map((E) => E.name);
+  vs(c, t), Rs(c, u), s && s.emit("applyFrameMetadata", e), e.type === void 0 && ks(c, t.stackParser);
+  const f = xs(r, n.captureContext);
+  n.mechanism && B(c, n.mechanism);
+  const l = s ? s.getEventProcessors() : [], m = br().getScopeData();
+  if (o) {
+    const E = o.getScopeData();
+    xe(m, E);
+  }
+  if (f) {
+    const E = f.getScopeData();
+    xe(m, E);
+  }
+  const d = [...n.attachments || [], ...m.attachments];
+  d.length && (n.attachments = d), gs(c, m);
+  const y = [
+    ...l,
+    // Run scope event processors _after_ all other processors
+    ...m.eventProcessors
+  ];
+  return Pt(y, c, n).then((E) => (E && ws(E), typeof i == "number" && i > 0 ? Ns(E, i, a) : E));
+}
+function vs(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 ks(t, e) {
+  const n = Ts(e);
+  t.exception?.values?.forEach((r) => {
+    r.stacktrace?.frames?.forEach((s) => {
+      s.filename && (s.debug_id = n[s.filename]);
+    });
+  });
+}
+function ws(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 Rs(t, e) {
+  e.length > 0 && (t.sdk = t.sdk || {}, t.sdk.integrations = [...t.sdk.integrations || [], ...e]);
+}
+function Ns(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 xs(t, e) {
+  if (!e)
+    return t;
+  const n = t ? t.clone() : new N();
+  return n.update(e), n;
+}
+function Os(t, e) {
+  return A().captureException(t, void 0);
+}
+function En(t, e) {
+  return A().captureEvent(t, e);
+}
+function Ds(t, e) {
+  z().setContext(t, e);
+}
+function De(t) {
+  const e = z(), n = A(), { userAgent: r } = g.navigator || {}, s = lr({
+    user: n.getUser() || e.getUser(),
+    ...r && { userAgent: r },
+    ...t
+  }), o = e.getSession();
+  return o?.status === "ok" && H(o, { status: "exited" }), Sn(), e.setSession(s), s;
+}
+function Sn() {
+  const t = z(), n = A().getSession() || t.getSession();
+  n && dr(n), bn(), t.setSession();
+}
+function bn() {
+  const t = z(), e = b(), n = t.getSession();
+  n && e && e.captureSession(n);
+}
+function Ae(t = !1) {
+  if (t) {
+    Sn();
+    return;
+  }
+  bn();
+}
+const As = "7";
+function Cs(t) {
+  const e = t.protocol ? `${t.protocol}:` : "", n = t.port ? `:${t.port}` : "";
+  return `${e}//${t.host}${n}${t.path ? `/${t.path}` : ""}/api/`;
+}
+function Ls(t) {
+  return `${Cs(t)}${t.projectId}/envelope/`;
+}
+function Ps(t, e) {
+  const n = {
+    sentry_version: As
+  };
+  return t.publicKey && (n.sentry_key = t.publicKey), e && (n.sentry_client = `${e.name}/${e.version}`), new URLSearchParams(n).toString();
+}
+function Ms(t, e, n) {
+  return e || `${Ls(t)}?${Ps(t, n)}`;
+}
+const Ce = [];
+function Fs(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 $s(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 Fs(r);
+}
+function Us(t, e) {
+  const n = {};
+  return e.forEach((r) => {
+    r && Tn(t, r, n);
+  }), n;
+}
+function Le(t, e) {
+  for (const n of e)
+    n?.afterAllSetup && n.afterAllSetup(t);
+}
+function Tn(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, Ce.indexOf(e.name) === -1 && typeof e.setupOnce == "function" && (e.setupOnce(), Ce.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 js(t, e, n) {
+  const r = [
+    { type: "client_report" },
+    {
+      timestamp: Q(),
+      discarded_events: t
+    }
+  ];
+  return et(e ? { dsn: e } : {}, [r]);
+}
+function In(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 Bs(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?.[fn],
+    exclusive_time: i?.[ln],
+    measurements: t.measurements,
+    is_segment: !0
+  };
+}
+function Hs(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 && { [fn]: t.profile_id },
+          ...t.exclusive_time && { [ln]: t.exclusive_time }
+        }
+      }
+    },
+    measurements: t.measurements
+  };
+}
+const Pe = "Not capturing exception because it's already been captured.", Me = "Discarded session because of missing or non-string release", vn = Symbol.for("SentryInternalError"), kn = Symbol.for("SentryDoNotSendEventError");
+function ut(t) {
+  return {
+    message: t,
+    [vn]: !0
+  };
+}
+function Rt(t) {
+  return {
+    message: t,
+    [kn]: !0
+  };
+}
+function Fe(t) {
+  return !!t && typeof t == "object" && vn in t;
+}
+function $e(t) {
+  return !!t && typeof t == "object" && kn in t;
+}
+class Gs {
+  /** 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 = Zr(e.dsn) : h && p.warn("No DSN provided, client will not send events."), this._dsn) {
+      const n = Ms(
+        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 (he(e))
+      return h && p.log(Pe), 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 = Vt(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 && he(n.originalException))
+      return h && p.log(Pe), 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), H(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))) : F(!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];
+    Tn(this, e, this._integrations), n || Le(this, [e]);
+  }
+  /**
+   * Send a fully prepared event to Sentry.
+   */
+  sendEvent(e, n = {}) {
+    this.emit("beforeSendEvent", e, n);
+    let r = ms(e, this._dsn, this._options._metadata, this._options.tunnel);
+    for (const o of n.attachments || [])
+      r = as(r, fs(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(Me);
+        return;
+      }
+      o.release = o.release || n, o.environment = o.environment || r, e.attrs = o;
+    } else {
+      if (!e.release && !n) {
+        h && p.warn(Me);
+        return;
+      }
+      e.release = e.release || n, e.environment = e.environment || r;
+    }
+    this.emit("beforeSendSession", e);
+    const s = hs(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"), F({}));
+  }
+  /* eslint-enable @typescript-eslint/unified-signatures */
+  /** Setup integrations for this client. */
+  _setupIntegrations() {
+    const { integrations: e } = this._options;
+    this._integrations = Us(this, e), Le(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) && (H(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 D((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), Is(o, e, n, r, this, s).then((a) => {
+      if (a === null)
+        return a;
+      this.emit("postprocessEvent", a, n), a.contexts = {
+        trace: Ir(r),
+        ...a.contexts
+      };
+      const c = ts(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 = A(), s = z()) {
+    return h && Mt(e) && p.log(`Captured error event \`${In(e)[0] || "<unknown>"}\``), this._processEvent(e, n, r, s).then(
+      (o) => o.event_id,
+      (o) => {
+        h && ($e(o) ? p.log(o.message) : Fe(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 = wn(e), c = Mt(e), u = e.type || "error", f = `before send for type \`${u}\``, l = typeof i > "u" ? void 0 : Fr(i);
+    if (c && typeof l == "number" && Math.random() > l)
+      return this.recordDroppedEvent("sample_rate", "error"), pt(
+        Rt(
+          `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), Rt("An event processor returned `null`, will not send event.");
+      if (n.data && n.data.__sentry__ === !0)
+        return d;
+      const X = qs(this, o, d, n);
+      return Ws(X, 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 Rt(`${f} returned \`null\`, will not send event.`);
+      }
+      const y = r.getSession() || s.getSession();
+      if (c && y && this._updateSessionFromEvent(y, d), a) {
+        const E = d.sdkProcessingMetadata?.spanCountBeforeProcessing || 0, Tt = d.spans ? d.spans.length : 0, oe = E - Tt;
+        oe > 0 && this.recordDroppedEvent("before_send", "span", oe);
+      }
+      const X = d.transaction_info;
+      if (a && X && d.transaction !== e.transaction) {
+        const E = "custom";
+        d.transaction_info = {
+          ...X,
+          source: E
+        };
+      }
+      return this.sendEvent(d, n), d;
+    }).then(null, (d) => {
+      throw $e(d) || Fe(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 = js(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 Ws(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 qs(t, e, n, r) {
+  const { beforeSend: s, beforeSendTransaction: o, beforeSendSpan: i } = e;
+  let a = n;
+  if (Mt(a) && s)
+    return s(a, r);
+  if (wn(a)) {
+    if (i) {
+      const c = i(Bs(a));
+      if (c ? a = tt(n, Hs(c)) : ve(), a.spans) {
+        const u = [];
+        for (const f of a.spans) {
+          const l = i(f);
+          l ? u.push(l) : (ve(), 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 wn(t) {
+  return t.type === "transaction";
+}
+function Ys(t) {
+  return [
+    {
+      type: "log",
+      item_count: t.length,
+      content_type: "application/vnd.sentry.items.log+json"
+    },
+    {
+      items: t
+    }
+  ];
+}
+function zs(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, [Ys(t)]);
+}
+function Nt(t, e) {
+  const n = Xs(t) ?? [];
+  if (n.length === 0)
+    return;
+  const r = t.getOptions(), s = zs(n, r._metadata, r.tunnel, t.getDsn());
+  Rn().set(t, []), t.emit("flushLogs"), t.sendEnvelope(s);
+}
+function Xs(t) {
+  return Rn().get(t);
+}
+function Rn() {
+  return Z("clientToLogBufferMap", () => /* @__PURE__ */ new WeakMap());
+}
+function Vs(t, e) {
+  e.debug === !0 && (h ? p.enable() : q(() => {
+    console.warn("[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.");
+  })), A().update(e.initialScope);
+  const r = new t(e);
+  return Ks(r), r.init(), r;
+}
+function Ks(t) {
+  A().setClient(t);
+}
+const Nn = Symbol.for("SentryBufferFullError");
+function Js(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(Nn);
+    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 D((a, c) => {
+      let u = e.length;
+      if (!u)
+        return a(!0);
+      const f = setTimeout(() => {
+        i && i > 0 && a(!1);
+      }, i);
+      e.forEach((l) => {
+        F(l).then(() => {
+          --u || (clearTimeout(f), a(!0));
+        }, c);
+      });
+    });
+  }
+  return {
+    $: e,
+    add: s,
+    drain: o
+  };
+}
+const Zs = 60 * 1e3;
+function Qs(t, e = Date.now()) {
+  const n = parseInt(`${t}`, 10);
+  if (!isNaN(n))
+    return n * 1e3;
+  const r = Date.parse(`${t}`);
+  return isNaN(r) ? Zs : r - e;
+}
+function to(t, e) {
+  return t[e] || t.all || 0;
+}
+function eo(t, e, n = Date.now()) {
+  return to(t, e) > n;
+}
+function no(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 + Qs(i, r) : e === 429 && (s.all = r + 60 * 1e3);
+  return s;
+}
+const ro = 64;
+function so(t, e, n = Js(
+  t.bufferSize || ro
+)) {
+  let r = {};
+  const s = (i) => n.drain(i);
+  function o(i) {
+    const a = [];
+    if (ke(i, (l, m) => {
+      const d = we(m);
+      eo(r, d) ? t.recordDroppedEvent("ratelimit_backoff", d) : a.push(l);
+    }), a.length === 0)
+      return F({});
+    const c = et(i[0], a), u = (l) => {
+      ke(c, (m, d) => {
+        t.recordDroppedEvent(l, we(d));
+      });
+    }, f = () => e({ body: cs(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 = no(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 === Nn)
+          return h && p.error("Skipped sending event because buffer is full."), u("queue_overflow"), F({});
+        throw l;
+      }
+    );
+  }
+  return {
+    send: o,
+    flush: s
+  };
+}
+function oo(t) {
+  t.user?.ip_address === void 0 && (t.user = {
+    ...t.user,
+    ip_address: "{{auto}}"
+  });
+}
+function io(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 xn(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: L
+    })),
+    version: L
+  }), t._metadata = s;
+}
+const ao = 100;
+function $(t, e) {
+  const n = b(), r = z();
+  if (!n) return;
+  const { beforeBreadcrumb: s = null, maxBreadcrumbs: o = ao } = n.getOptions();
+  if (o <= 0) return;
+  const a = { timestamp: Q(), ...t }, c = s ? q(() => s(a, e)) : a;
+  c !== null && (n.emit && n.emit("beforeAddBreadcrumb", c, e), r.addBreadcrumb(c, o));
+}
+let Ue;
+const co = "FunctionToString", je = /* @__PURE__ */ new WeakMap(), uo = (() => ({
+  name: co,
+  setupOnce() {
+    Ue = Function.prototype.toString;
+    try {
+      Function.prototype.toString = function(...t) {
+        const e = Zt(this), n = je.has(b()) && e !== void 0 ? e : this;
+        return Ue.apply(n, t);
+      };
+    } catch {
+    }
+  },
+  setup(t) {
+    je.set(t, !0);
+  }
+})), fo = uo, lo = [
+  /^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)
+], po = "EventFilters", ho = (t = {}) => {
+  let e;
+  return {
+    name: po,
+    setup(n) {
+      const r = n.getOptions();
+      e = Be(t, r);
+    },
+    processEvent(n, r, s) {
+      if (!e) {
+        const o = s.getOptions();
+        e = Be(t, o);
+      }
+      return go(n, e) ? null : n;
+    }
+  };
+}, mo = ((t = {}) => ({
+  ...ho(t),
+  name: "InboundFilters"
+}));
+function Be(t = {}, e = {}) {
+  return {
+    allowUrls: [...t.allowUrls || [], ...e.allowUrls || []],
+    denyUrls: [...t.denyUrls || [], ...e.denyUrls || []],
+    ignoreErrors: [
+      ...t.ignoreErrors || [],
+      ...e.ignoreErrors || [],
+      ...t.disableErrorDefaults ? [] : lo
+    ],
+    ignoreTransactions: [...t.ignoreTransactions || [], ...e.ignoreTransactions || []]
+  };
+}
+function go(t, e) {
+  if (t.type) {
+    if (t.type === "transaction" && yo(t, e.ignoreTransactions))
+      return h && p.warn(
+        `Event dropped due to being matched by \`ignoreTransactions\` option.
+Event: ${C(t)}`
+      ), !0;
+  } else {
+    if (_o(t, e.ignoreErrors))
+      return h && p.warn(
+        `Event dropped due to being matched by \`ignoreErrors\` option.
+Event: ${C(t)}`
+      ), !0;
+    if (To(t))
+      return h && p.warn(
+        `Event dropped due to not having an error message, error type or stacktrace.
+Event: ${C(
+          t
+        )}`
+      ), !0;
+    if (Eo(t, e.denyUrls))
+      return h && p.warn(
+        `Event dropped due to being matched by \`denyUrls\` option.
+Event: ${C(
+          t
+        )}.
+Url: ${ht(t)}`
+      ), !0;
+    if (!So(t, e.allowUrls))
+      return h && p.warn(
+        `Event dropped due to not being matched by \`allowUrls\` option.
+Event: ${C(
+          t
+        )}.
+Url: ${ht(t)}`
+      ), !0;
+  }
+  return !1;
+}
+function _o(t, e) {
+  return e?.length ? In(t).some((n) => Et(n, e)) : !1;
+}
+function yo(t, e) {
+  if (!e?.length)
+    return !1;
+  const n = t.transaction;
+  return n ? Et(n, e) : !1;
+}
+function Eo(t, e) {
+  if (!e?.length)
+    return !1;
+  const n = ht(t);
+  return n ? Et(n, e) : !1;
+}
+function So(t, e) {
+  if (!e?.length)
+    return !0;
+  const n = ht(t);
+  return n ? Et(n, e) : !0;
+}
+function bo(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 ? bo(n) : null;
+  } catch {
+    return h && p.error(`Cannot extract url for event ${C(t)}`), null;
+  }
+}
+function To(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 Io(t, e, n, r, s, o) {
+  if (!s.exception?.values || !o || !O(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 (O(r[s], Error)) {
+    He(i, a);
+    const u = t(e, r[s]), f = c.length;
+    Ge(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 (O(u, Error)) {
+      He(i, a);
+      const l = t(e, u), m = c.length;
+      Ge(l, `errors[${f}]`, m, a), c = Ft(
+        t,
+        e,
+        n,
+        u,
+        s,
+        [l, ...c],
+        l,
+        m
+      );
+    }
+  }), c;
+}
+function He(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 Ge(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 vo(t) {
+  const e = "console";
+  U(e, t), j(e, ko);
+}
+function ko() {
+  "console" in g && Un.forEach(function(t) {
+    t in g.console && T(g.console, t, function(e) {
+      return lt[t] = e, function(...n) {
+        v("console", { args: n, level: t }), lt[t]?.apply(g.console, n);
+      };
+    });
+  });
+}
+function wo(t) {
+  return t === "warn" ? "warning" : ["fatal", "error", "warning", "log", "info", "debug"].includes(t) ? t : "log";
+}
+const Ro = "Dedupe", No = (() => {
+  let t;
+  return {
+    name: Ro,
+    processEvent(e) {
+      if (e.type)
+        return e;
+      try {
+        if (Oo(e, t))
+          return h && p.warn("Event dropped due to being a duplicate of previously captured event."), null;
+      } catch {
+      }
+      return t = e;
+    }
+  };
+}), xo = No;
+function Oo(t, e) {
+  return e ? !!(Do(t, e) || Ao(t, e)) : !1;
+}
+function Do(t, e) {
+  const n = t.message, r = e.message;
+  return !(!n && !r || n && !r || !n && r || n !== r || !Dn(t, e) || !On(t, e));
+}
+function Ao(t, e) {
+  const n = We(e), r = We(t);
+  return !(!n || !r || n.type !== r.type || n.value !== r.value || !Dn(t, e) || !On(t, e));
+}
+function On(t, e) {
+  let n = ce(t), r = ce(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 Dn(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 We(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 An(t) {
+  if (t !== void 0)
+    return t >= 400 && t < 500 ? "warning" : t >= 500 ? "error" : void 0;
+}
+const J = g;
+function Co() {
+  return "history" in J && !!J.history;
+}
+function Lo() {
+  if (!("fetch" in J))
+    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 Po() {
+  if (typeof EdgeRuntime == "string")
+    return !0;
+  if (!Lo())
+    return !1;
+  if ($t(J.fetch))
+    return !0;
+  let t = !1;
+  const e = J.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 Mo(t, e) {
+  const n = "fetch";
+  U(n, t), j(n, () => Fo(void 0, e));
+}
+function Fo(t, e = !1) {
+  e && !Po() || T(g, "fetch", function(n) {
+    return function(...r) {
+      const s = new Error(), { method: o, url: i } = $o(r), a = {
+        args: r,
+        fetchData: {
+          method: o,
+          url: i
+        },
+        startTimestamp: R() * 1e3,
+        // // Adding the error to be able to fingerprint the failed fetch event in HttpClient instrumentation
+        virtualError: s,
+        headers: Uo(r)
+      };
+      return v("fetch", {
+        ...a
+      }), n.apply(g, r).then(
+        async (c) => (v("fetch", {
+          ...a,
+          endTimestamp: R() * 1e3,
+          response: c
+        }), c),
+        (c) => {
+          if (v("fetch", {
+            ...a,
+            endTimestamp: R() * 1e3,
+            error: c
+          }), zt(c) && c.stack === void 0 && (c.stack = s.stack, M(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 qe(t) {
+  return typeof t == "string" ? t : t ? Ut(t, "url") ? t.url : t.toString ? t.toString() : "" : "";
+}
+function $o(t) {
+  if (t.length === 0)
+    return { method: "GET", url: "" };
+  if (t.length === 2) {
+    const [n, r] = t;
+    return {
+      url: qe(n),
+      method: Ut(r, "method") ? String(r.method).toUpperCase() : "GET"
+    };
+  }
+  const e = t[0];
+  return {
+    url: qe(e),
+    method: Ut(e, "method") ? String(e.method).toUpperCase() : "GET"
+  };
+}
+function Uo(t) {
+  const [e, n] = t;
+  try {
+    if (typeof n == "object" && n !== null && "headers" in n && n.headers)
+      return new Headers(n.headers);
+    if (nr(e))
+      return new Headers(e.headers);
+  } catch {
+  }
+}
+function jo() {
+  return "npm";
+}
+const _ = g;
+let jt = 0;
+function Cn() {
+  return jt > 0;
+}
+function Bo() {
+  jt++, setTimeout(() => {
+    jt--;
+  });
+}
+function W(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) => W(i, e));
+      return t.apply(this, o);
+    } catch (o) {
+      throw Bo(), Tr((i) => {
+        i.addEventProcessor((a) => (e.mechanism && (Dt(a, void 0), B(a, e.mechanism)), a.extra = {
+          ...a.extra,
+          arguments: s
+        }, a)), Os(o);
+      }), o;
+    }
+  };
+  try {
+    for (const s in t)
+      Object.prototype.hasOwnProperty.call(t, s) && (r[s] = t[s]);
+  } catch {
+  }
+  sn(r, t), M(t, "__sentry_wrapped__", r);
+  try {
+    Object.getOwnPropertyDescriptor(r, "name").configurable && Object.defineProperty(r, "name", {
+      get() {
+        return t.name;
+      }
+    });
+  } catch {
+  }
+  return r;
+}
+function Ho() {
+  const t = Jt(), { referrer: e } = _.document || {}, { userAgent: n } = _.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: zo(e),
+    value: Xo(e)
+  };
+  return n.length && (r.stacktrace = { frames: n }), r.type === void 0 && r.value === "" && (r.value = "Unrecoverable error caught"), r;
+}
+function Go(t, e, n, r) {
+  const o = b()?.getOptions().normalizeDepth, i = Qo(e), a = {
+    __serialized__: _n(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: Jo(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 = qo(e), s = Yo(e);
+  try {
+    return t(n, r, s);
+  } catch {
+  }
+  return [];
+}
+const Wo = /Minified React error #\d+;/i;
+function qo(t) {
+  return t && Wo.test(t.message) ? 1 : 0;
+}
+function Yo(t) {
+  return typeof t.framesToPop == "number" ? t.framesToPop : 0;
+}
+function Ln(t) {
+  return typeof WebAssembly < "u" && typeof WebAssembly.Exception < "u" ? t instanceof WebAssembly.Exception : !1;
+}
+function zo(t) {
+  const e = t?.name;
+  return !e && Ln(t) ? t.message && Array.isArray(t.message) && t.message.length == 2 ? t.message[0] : "WebAssembly.Exception" : e;
+}
+function Xo(t) {
+  const e = t?.message;
+  return Ln(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 Vo(t, e, n, r) {
+  const s = n?.syntheticException || void 0, o = se(t, e, s, r);
+  return B(o), o.level = "error", n?.event_id && (o.event_id = n.event_id), F(o);
+}
+function Ko(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), F(i);
+}
+function se(t, e, n, r, s) {
+  let o;
+  if (en(e) && e.error)
+    return Ot(t, e.error);
+  if (fe(e) || Zn(e)) {
+    const i = e;
+    if ("stack" in e)
+      o = Ot(t, e);
+    else {
+      const a = i.name || (fe(i) ? "DOMError" : "DOMException"), c = i.message ? `${a}: ${i.message}` : a;
+      o = Bt(t, c, n, r), Dt(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 = Go(t, e, n, s), B(o, {
+    synthetic: !0
+  }), o) : (o = Bt(t, e, n, r), Dt(o, `${e}`), B(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 } }]
+    }), B(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 Jo(t, { isUnhandledRejection: e }) {
+  const n = ar(t), r = e ? "promise rejection" : "exception";
+  return en(t) ? `Event \`ErrorEvent\` captured as ${r} with message \`${t.message}\`` : _t(t) ? `Event \`${Zo(t)}\` (type=${t.type}) captured as ${r}` : `Object captured as ${r} with keys: ${n}`;
+}
+function Zo(t) {
+  try {
+    const e = Object.getPrototypeOf(t);
+    return e ? e.constructor.name : void 0;
+  } catch {
+  }
+}
+function Qo(t) {
+  for (const e in t)
+    if (Object.prototype.hasOwnProperty.call(t, e)) {
+      const n = t[e];
+      if (n instanceof Error)
+        return n;
+    }
+}
+const ti = 5e3;
+class ei extends Gs {
+  /**
+   * Creates a new Browser SDK instance.
+   *
+   * @param options Configuration options for this SDK.
+   */
+  constructor(e) {
+    const n = ni(e), r = _.SENTRY_SDK_SOURCE || jo();
+    xn(n, "browser", ["browser"], r), super(n);
+    const { sendDefaultPii: s, sendClientReports: o, enableLogs: i, _experiments: a } = this._options, c = i ?? a?.enableLogs;
+    _.document && (o || c) && _.document.addEventListener("visibilitychange", () => {
+      _.document.visibilityState === "hidden" && (o && this._flushOutcomes(), c && Nt(this));
+    }), c && (this.on("flush", () => {
+      Nt(this);
+    }), this.on("afterCaptureLog", () => {
+      this._logFlushIdleTimeout && clearTimeout(this._logFlushIdleTimeout), this._logFlushIdleTimeout = setTimeout(() => {
+        Nt(this);
+      }, ti);
+    })), s && (this.on("postprocessEvent", oo), this.on("beforeSendSession", io));
+  }
+  /**
+   * @inheritDoc
+   */
+  eventFromException(e, n) {
+    return Vo(this._options.stackParser, e, n, this._options.attachStacktrace);
+  }
+  /**
+   * @inheritDoc
+   */
+  eventFromMessage(e, n = "info", r) {
+    return Ko(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 ni(t) {
+  return {
+    release: typeof __SENTRY_RELEASE__ == "string" ? __SENTRY_RELEASE__ : _.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 ri = typeof __SENTRY_DEBUG__ > "u" || __SENTRY_DEBUG__, S = g, si = 1e3;
+let Ye, Ht, Gt;
+function oi(t) {
+  U("dom", t), j("dom", ii);
+}
+function ii() {
+  if (!S.document)
+    return;
+  const t = v.bind(null, "dom"), e = ze(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 = ze(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 ai(t) {
+  if (t.type !== Ht)
+    return !1;
+  try {
+    if (!t.target || t.target._sentryId !== Gt)
+      return !1;
+  } catch {
+  }
+  return !0;
+}
+function ci(t, e) {
+  return t !== "keypress" ? !1 : e?.tagName ? !(e.tagName === "INPUT" || e.tagName === "TEXTAREA" || e.isContentEditable) : !0;
+}
+function ze(t, e = !1) {
+  return (n) => {
+    if (!n || n._sentryCaptured)
+      return;
+    const r = ui(n);
+    if (ci(n.type, r))
+      return;
+    M(n, "_sentryCaptured", !0), r && !r._sentryId && M(r, "_sentryId", I());
+    const s = n.type === "keypress" ? "input" : n.type;
+    ai(n) || (t({ event: n, name: s, global: e }), Ht = n.type, Gt = r ? r._sentryId : void 0), clearTimeout(Ye), Ye = S.setTimeout(() => {
+      Gt = void 0, Ht = void 0;
+    }, si);
+  };
+}
+function ui(t) {
+  try {
+    return t.target;
+  } catch {
+    return null;
+  }
+}
+let it;
+function Pn(t) {
+  const e = "history";
+  U(e, t), j(e, fi);
+}
+function fi() {
+  if (S.addEventListener("popstate", () => {
+    const e = S.location.href, n = it;
+    if (it = e, n === e)
+      return;
+    v("history", { from: n, to: e });
+  }), !Co())
+    return;
+  function t(e) {
+    return function(...n) {
+      const r = n.length > 2 ? n[2] : void 0;
+      if (r) {
+        const s = it, o = li(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 li(t) {
+  try {
+    return new URL(t, S.location.origin).toString();
+  } catch {
+    return t;
+  }
+}
+const ft = {};
+function di(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) {
+      ri && p.warn(`Could not create sandbox iframe for ${t} check, bailing to window.${t}: `, s);
+    }
+  return n && (ft[t] = n.bind(S));
+}
+function Xe(t) {
+  ft[t] = void 0;
+}
+const V = "__sentry_xhr_v3__";
+function pi(t) {
+  U("xhr", t), j("xhr", hi);
+}
+function hi() {
+  if (!S.XMLHttpRequest)
+    return;
+  const t = XMLHttpRequest.prototype;
+  t.open = new Proxy(t.open, {
+    apply(e, n, r) {
+      const s = new Error(), o = R() * 1e3, i = w(r[0]) ? r[0].toUpperCase() : void 0, a = mi(r[1]);
+      if (!i || !a)
+        return e.apply(n, r);
+      n[V] = {
+        method: i,
+        url: a,
+        request_headers: {}
+      }, i === "POST" && a.match(/sentry_key/) && (n.__sentry_own_request__ = !0);
+      const c = () => {
+        const u = n[V];
+        if (u && n.readyState === 4) {
+          try {
+            u.status_code = n.status;
+          } catch {
+          }
+          const f = {
+            endTimestamp: R() * 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, y = f[V];
+          return y && w(m) && w(d) && (y.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[V];
+      if (!s)
+        return e.apply(n, r);
+      r[0] !== void 0 && (s.body = r[0]);
+      const o = {
+        startTimestamp: R() * 1e3,
+        xhr: n
+      };
+      return v("xhr", o), e.apply(n, r);
+    }
+  });
+}
+function mi(t) {
+  if (w(t))
+    return t;
+  try {
+    return t.toString();
+  } catch {
+  }
+}
+function gi(t, e = di("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 Xe("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 Xe("fetch"), n -= i, r--, pt(c);
+    }
+  }
+  return so(t, s);
+}
+const _i = 30, yi = 50;
+function Wt(t, e, n, r) {
+  const s = {
+    filename: t,
+    function: e === "<anonymous>" ? P : 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 Ei = /^\s*at (\S+?)(?::(\d+))(?::(\d+))\s*$/i, Si = /^\s*at (?:(.+?\)(?: \[.+\])?|.*?) ?\((?:address at )?)?(?:async )?((?:<anonymous>|[-a-z]+:|.*bundle|\/)?.*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i, bi = /\((\S*)(?::(\d+))(?::(\d+))\)/, Ti = (t) => {
+  const e = Ei.exec(t);
+  if (e) {
+    const [, r, s, o] = e;
+    return Wt(r, P, +s, +o);
+  }
+  const n = Si.exec(t);
+  if (n) {
+    if (n[2] && n[2].indexOf("eval") === 0) {
+      const i = bi.exec(n[2]);
+      i && (n[2] = i[1], n[3] = i[2], n[4] = i[3]);
+    }
+    const [s, o] = Mn(n[1] || P, n[2]);
+    return Wt(o, s, n[3] ? +n[3] : void 0, n[4] ? +n[4] : void 0);
+  }
+}, Ii = [_i, Ti], vi = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)?((?:[-a-z]+)?:\/.*?|\[native code\]|[^@]*(?:bundle|\d+\.js)|\/[\w\-. /=]+)(?::(\d+))?(?::(\d+))?\s*$/i, ki = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i, wi = (t) => {
+  const e = vi.exec(t);
+  if (e) {
+    if (e[3] && e[3].indexOf(" > eval") > -1) {
+      const o = ki.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] || P;
+    return [s, r] = Mn(s, r), Wt(r, s, e[4] ? +e[4] : void 0, e[5] ? +e[5] : void 0);
+  }
+}, Ri = [yi, wi], Ni = [Ii, Ri], xi = Qe(...Ni), Mn = (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] : P,
+    n ? `safari-extension:${e}` : `safari-web-extension:${e}`
+  ] : [t, e];
+}, bt = typeof __SENTRY_DEBUG__ > "u" || __SENTRY_DEBUG__, at = 1024, Oi = "Breadcrumbs", Di = ((t = {}) => {
+  const e = {
+    console: !0,
+    dom: !0,
+    fetch: !0,
+    history: !0,
+    sentry: !0,
+    xhr: !0,
+    ...t
+  };
+  return {
+    name: Oi,
+    setup(n) {
+      e.console && vo(Pi(n)), e.dom && oi(Li(n, e.dom)), e.xhr && pi(Mi(n)), e.fetch && Mo(Fi(n)), e.history && Pn($i(n)), e.sentry && n.on("beforeSendEvent", Ci(n));
+    }
+  };
+}), Ai = Di;
+function Ci(t) {
+  return function(n) {
+    b() === t && $(
+      {
+        category: `sentry.${n.type === "transaction" ? "transaction" : "event"}`,
+        event_id: n.event_id,
+        level: n.level,
+        message: C(n)
+      },
+      {
+        event: n
+      }
+    );
+  };
+}
+function Li(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 = Ui(u) ? u.target : u;
+      s = rn(f, { keyAttrs: i, maxStringLength: a }), o = or(f);
+    } catch {
+      s = "<unknown>";
+    }
+    if (s.length === 0)
+      return;
+    const c = {
+      category: `ui.${r.name}`,
+      message: s
+    };
+    o && (c.data = { "ui.component_name": o }), $(c, {
+      event: r.event,
+      name: r.name,
+      global: r.global
+    });
+  };
+}
+function Pi(t) {
+  return function(n) {
+    if (b() !== t)
+      return;
+    const r = {
+      category: "console",
+      data: {
+        arguments: n.args,
+        logger: "console"
+      },
+      level: wo(n.level),
+      message: le(n.args, " ")
+    };
+    if (n.level === "assert")
+      if (n.args[0] === !1)
+        r.message = `Assertion failed: ${le(n.args.slice(1), " ") || "console.assert"}`, r.data.arguments = n.args.slice(1);
+      else
+        return;
+    $(r, {
+      input: n.args,
+      level: n.level
+    });
+  };
+}
+function Mi(t) {
+  return function(n) {
+    if (b() !== t)
+      return;
+    const { startTimestamp: r, endTimestamp: s } = n, o = n.xhr[V];
+    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: An(c)
+    };
+    t.emit("beforeOutgoingRequestBreadcrumb", m, l), $(m, l);
+  };
+}
+function Fi(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), $(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: An(i.status_code)
+        };
+        t.emit("beforeOutgoingRequestBreadcrumb", c, a), $(c, a);
+      }
+  };
+}
+function $i(t) {
+  return function(n) {
+    if (b() !== t)
+      return;
+    let r = n.from, s = n.to;
+    const o = xt(_.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), $({
+      category: "navigation",
+      data: {
+        from: r,
+        to: s
+      }
+    });
+  };
+}
+function Ui(t) {
+  return !!t && !!t.target;
+}
+const ji = [
+  "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"
+], Bi = "BrowserApiErrors", Hi = ((t = {}) => {
+  const e = {
+    XMLHttpRequest: !0,
+    eventTarget: !0,
+    requestAnimationFrame: !0,
+    setInterval: !0,
+    setTimeout: !0,
+    unregisterOriginalCallbacks: !1,
+    ...t
+  };
+  return {
+    name: Bi,
+    // 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(_, "setTimeout", Ve), e.setInterval && T(_, "setInterval", Ve), e.requestAnimationFrame && T(_, "requestAnimationFrame", Wi), e.XMLHttpRequest && "XMLHttpRequest" in _ && T(XMLHttpRequest.prototype, "send", qi);
+      const n = e.eventTarget;
+      n && (Array.isArray(n) ? n : ji).forEach((s) => Yi(s, e));
+    }
+  };
+}), Gi = Hi;
+function Ve(t) {
+  return function(...e) {
+    const n = e[0];
+    return e[0] = W(n, {
+      mechanism: {
+        data: { function: x(t) },
+        handled: !1,
+        type: "instrument"
+      }
+    }), t.apply(this, e);
+  };
+}
+function Wi(t) {
+  return function(e) {
+    return t.apply(this, [
+      W(e, {
+        mechanism: {
+          data: {
+            function: "requestAnimationFrame",
+            handler: x(t)
+          },
+          handled: !1,
+          type: "instrument"
+        }
+      })
+    ]);
+  };
+}
+function qi(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: x(o)
+            },
+            handled: !1,
+            type: "instrument"
+          }
+        }, a = Zt(o);
+        return a && (i.mechanism.data.handler = x(a)), W(o, i);
+      });
+    }), t.apply(this, e);
+  };
+}
+function Yi(t, e) {
+  const r = _[t]?.prototype;
+  r?.hasOwnProperty?.("addEventListener") && (T(r, "addEventListener", function(s) {
+    return function(o, i, a) {
+      try {
+        zi(i) && (i.handleEvent = W(i.handleEvent, {
+          mechanism: {
+            data: {
+              function: "handleEvent",
+              handler: x(i),
+              target: t
+            },
+            handled: !1,
+            type: "instrument"
+          }
+        }));
+      } catch {
+      }
+      return e.unregisterOriginalCallbacks && Xi(this, o, i), s.apply(this, [
+        o,
+        W(i, {
+          mechanism: {
+            data: {
+              function: "addEventListener",
+              handler: x(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 zi(t) {
+  return typeof t.handleEvent == "function";
+}
+function Xi(t, e, n) {
+  t && typeof t == "object" && "removeEventListener" in t && typeof t.removeEventListener == "function" && t.removeEventListener(e, n);
+}
+const Vi = () => ({
+  name: "BrowserSession",
+  setupOnce() {
+    if (typeof _.document > "u") {
+      bt && p.warn("Using the `browserSessionIntegration` in non-browser environments is not supported.");
+      return;
+    }
+    De({ ignoreDuration: !0 }), Ae(), Pn(({ from: t, to: e }) => {
+      t !== void 0 && t !== e && (De({ ignoreDuration: !0 }), Ae());
+    });
+  }
+}), Ki = "GlobalHandlers", Ji = ((t = {}) => {
+  const e = {
+    onerror: !0,
+    onunhandledrejection: !0,
+    ...t
+  };
+  return {
+    name: Ki,
+    setupOnce() {
+      Error.stackTraceLimit = 50;
+    },
+    setup(n) {
+      e.onerror && (Qi(n), Ke("onerror")), e.onunhandledrejection && (ta(n), Ke("onunhandledrejection"));
+    }
+  };
+}), Zi = Ji;
+function Qi(t) {
+  Xn((e) => {
+    const { stackParser: n, attachStacktrace: r } = Fn();
+    if (b() !== t || Cn())
+      return;
+    const { msg: s, url: o, line: i, column: a, error: c } = e, u = ra(
+      se(n, c || s, void 0, r, !1),
+      o,
+      i,
+      a
+    );
+    u.level = "error", En(u, {
+      originalException: c,
+      mechanism: {
+        handled: !1,
+        type: "onerror"
+      }
+    });
+  });
+}
+function ta(t) {
+  Kn((e) => {
+    const { stackParser: n, attachStacktrace: r } = Fn();
+    if (b() !== t || Cn())
+      return;
+    const s = ea(e), o = Vt(s) ? na(s) : se(n, s, void 0, r, !0);
+    o.level = "error", En(o, {
+      originalException: s,
+      mechanism: {
+        handled: !1,
+        type: "onunhandledrejection"
+      }
+    });
+  });
+}
+function ea(t) {
+  if (Vt(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 na(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 ra(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 = w(e) && e.length > 0 ? e : Jt();
+  return c.length === 0 && c.push({
+    colno: u,
+    filename: l,
+    function: P,
+    in_app: !0,
+    lineno: f
+  }), t;
+}
+function Ke(t) {
+  bt && p.log(`Global Handler attached: ${t}`);
+}
+function Fn() {
+  return b()?.getOptions() || {
+    stackParser: () => [],
+    attachStacktrace: !1
+  };
+}
+const sa = () => ({
+  name: "HttpContext",
+  preprocessEvent(t) {
+    if (!_.navigator && !_.location && !_.document)
+      return;
+    const e = Ho(), n = {
+      ...e.headers,
+      ...t.request?.headers
+    };
+    t.request = {
+      ...e,
+      ...t.request,
+      headers: n
+    };
+  }
+}), oa = "cause", ia = 5, aa = "LinkedErrors", ca = ((t = {}) => {
+  const e = t.limit || ia, n = t.key || oa;
+  return {
+    name: aa,
+    preprocessEvent(r, s, o) {
+      const i = o.getOptions();
+      Io(
+        // This differs from the LinkedErrors integration in core by using a different exceptionFromError function
+        ne,
+        i.stackParser,
+        n,
+        e,
+        r,
+        s
+      );
+    }
+  };
+}), ua = ca;
+function fa() {
+  return la() ? (bt && q(() => {
+    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 la() {
+  if (typeof _.window > "u")
+    return !1;
+  const t = _;
+  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 !(_ === _.top && r.some((o) => n.startsWith(`${o}://`)));
+}
+function da(t) {
+  return [
+    // TODO(v10): Replace with `eventFiltersIntegration` once we remove the deprecated `inboundFiltersIntegration`
+    // eslint-disable-next-line deprecation/deprecation
+    mo(),
+    fo(),
+    Gi(),
+    Ai(),
+    Zi(),
+    ua(),
+    xo(),
+    sa(),
+    Vi()
+  ];
+}
+function pa(t = {}) {
+  const e = !t.skipBrowserExtensionCheck && fa(), n = {
+    ...t,
+    enabled: e ? !1 : t.enabled,
+    stackParser: Yn(t.stackParser || xi),
+    integrations: $s({
+      integrations: t.integrations,
+      defaultIntegrations: t.defaultIntegrations == null ? da() : t.defaultIntegrations
+    }),
+    transport: t.transport || gi
+  };
+  return Vs(ei, n);
+}
+function ma(t) {
+  const e = {
+    ...t
+  };
+  return xn(e, "react"), Ds("react", { version: $n }), pa(e);
+}
+export {
+  ei as BrowserClient,
+  L as SDK_VERSION,
+  Rr as SEMANTIC_ATTRIBUTE_SENTRY_OP,
+  Nr as SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
+  kr as SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE,
+  vr as SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
+  N as Scope,
+  _ as WINDOW,
+  $ as addBreadcrumb,
+  Ai as breadcrumbsIntegration,
+  Gi as browserApiErrorsIntegration,
+  Vi as browserSessionIntegration,
+  En as captureEvent,
+  Os as captureException,
+  Ae as captureSession,
+  Ii as chromeStackLineParser,
+  so as createTransport,
+  xo as dedupeIntegration,
+  Ni as defaultStackLineParsers,
+  xi as defaultStackParser,
+  Sn as endSession,
+  ho as eventFiltersIntegration,
+  Vo as eventFromException,
+  Ko as eventFromMessage,
+  ne as exceptionFromError,
+  fo as functionToStringIntegration,
+  Ri as geckoStackLineParser,
+  b as getClient,
+  A as getCurrentScope,
+  da as getDefaultIntegrations,
+  br as getGlobalScope,
+  z as getIsolationScope,
+  hn as getRootSpan,
+  Zi as globalHandlersIntegration,
+  sa as httpContextIntegration,
+  mo as inboundFiltersIntegration,
+  ma as init,
+  ua as linkedErrorsIntegration,
+  gi as makeFetchTransport,
+  Ds as setContext,
+  Ks as setCurrentClient,
+  te as spanToJSON,
+  De as startSession,
+  Tr as withScope
+};
+//# sourceMappingURL=index-hFbiYJI3.js.map