@konnectio/core 4.0.61 → 4.0.62

package/dist/_commonjsHelpers-DZ_3pocK.js

@@ -0,0 +1,2590 @@
+import "./_sentry-release-injection-file-gnd2S326.js";
+(function() {
+  try {
+    var t = typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, e = new Error().stack;
+    e && (t._sentryDebugIds = t._sentryDebugIds || {}, t._sentryDebugIds[e] = "f40c230a-78da-483f-b571-a8ec8890deef", t._sentryDebugIdIdentifier = "sentry-dbid-f40c230a-78da-483f-b571-a8ec8890deef");
+  } catch {
+  }
+})();
+const Jt = Object.prototype.toString;
+function Se(t) {
+  switch (Jt.call(t)) {
+    case "[object Error]":
+    case "[object Exception]":
+    case "[object DOMException]":
+      return !0;
+    default:
+      return V(t, Error);
+  }
+}
+function L(t, e) {
+  return Jt.call(t) === `[object ${e}]`;
+}
+function Sr(t) {
+  return L(t, "ErrorEvent");
+}
+function yr(t) {
+  return L(t, "DOMError");
+}
+function Er(t) {
+  return L(t, "DOMException");
+}
+function z(t) {
+  return L(t, "String");
+}
+function ye(t) {
+  return typeof t == "object" && t !== null && "__sentry_template_string__" in t && "__sentry_template_values__" in t;
+}
+function br(t) {
+  return t === null || ye(t) || typeof t != "object" && typeof t != "function";
+}
+function dt(t) {
+  return L(t, "Object");
+}
+function Ee(t) {
+  return typeof Event < "u" && V(t, Event);
+}
+function be(t) {
+  return typeof Element < "u" && V(t, Element);
+}
+function Te(t) {
+  return L(t, "RegExp");
+}
+function pt(t) {
+  return !!(t && t.then && typeof t.then == "function");
+}
+function Ie(t) {
+  return dt(t) && "nativeEvent" in t && "preventDefault" in t && "stopPropagation" in t;
+}
+function V(t, e) {
+  try {
+    return t instanceof e;
+  } catch {
+    return !1;
+  }
+}
+function Kt(t) {
+  return !!(typeof t == "object" && t !== null && (t.__isVue || t._isVue));
+}
+function G(t, e = 0) {
+  return typeof t != "string" || e === 0 || t.length <= e ? t : `${t.slice(0, e)}...`;
+}
+function Tr(t, e) {
+  if (!Array.isArray(t))
+    return "";
+  const n = [];
+  for (let r = 0; r < t.length; r++) {
+    const s = t[r];
+    try {
+      Kt(s) ? n.push("[VueViewModel]") : n.push(String(s));
+    } catch {
+      n.push("[value cannot be serialized]");
+    }
+  }
+  return n.join(e);
+}
+function Ne(t, e, n = !1) {
+  return z(t) ? Te(e) ? e.test(t) : z(e) ? n ? t === e : t.includes(e) : !1 : !1;
+}
+function Ir(t, e = [], n = !1) {
+  return e.some((r) => Ne(t, r, n));
+}
+const B = "8.14.0", h = globalThis;
+function lt(t, e, n) {
+  const r = n || h, s = r.__SENTRY__ = r.__SENTRY__ || {}, i = s[B] = s[B] || {};
+  return i[t] || (i[t] = e());
+}
+const w = h, Ae = 80;
+function Oe(t, e = {}) {
+  if (!t)
+    return "<unknown>";
+  try {
+    let n = t;
+    const r = 5, s = [];
+    let i = 0, o = 0;
+    const a = " > ", u = a.length;
+    let c;
+    const f = Array.isArray(e) ? e : e.keyAttrs, d = !Array.isArray(e) && e.maxStringLength || Ae;
+    for (; n && i++ < r && (c = Re(n, f), !(c === "html" || i > 1 && o + s.length * u + c.length >= d)); )
+      s.push(c), o += c.length, n = n.parentNode;
+    return s.reverse().join(a);
+  } catch {
+    return "<unknown>";
+  }
+}
+function Re(t, e) {
+  const n = t, r = [];
+  if (!n || !n.tagName)
+    return "";
+  if (w.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 && e.length ? e.filter((o) => n.getAttribute(o)).map((o) => [o, n.getAttribute(o)]) : null;
+  if (s && s.length)
+    s.forEach((o) => {
+      r.push(`[${o[0]}="${o[1]}"]`);
+    });
+  else {
+    n.id && r.push(`#${n.id}`);
+    const o = n.className;
+    if (o && z(o)) {
+      const a = o.split(/\s+/);
+      for (const u of a)
+        r.push(`.${u}`);
+    }
+  }
+  const i = ["aria-label", "type", "name", "title", "alt"];
+  for (const o of i) {
+    const a = n.getAttribute(o);
+    a && r.push(`[${o}="${a}"]`);
+  }
+  return r.join("");
+}
+function Nr() {
+  try {
+    return w.document.location.href;
+  } catch {
+    return "";
+  }
+}
+function Ar(t) {
+  return w.document && w.document.querySelector ? w.document.querySelector(t) : null;
+}
+function Or(t) {
+  if (!w.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;
+}
+const W = typeof __SENTRY_DEBUG__ > "u" || __SENTRY_DEBUG__, De = "Sentry Logger ", Nt = [
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "log",
+  "assert",
+  "trace"
+], At = {};
+function _t(t) {
+  if (!("console" in h))
+    return t();
+  const e = h.console, n = {}, r = Object.keys(At);
+  r.forEach((s) => {
+    const i = At[s];
+    n[s] = e[s], e[s] = i;
+  });
+  try {
+    return t();
+  } finally {
+    r.forEach((s) => {
+      e[s] = n[s];
+    });
+  }
+}
+function Ce() {
+  let t = !1;
+  const e = {
+    enable: () => {
+      t = !0;
+    },
+    disable: () => {
+      t = !1;
+    },
+    isEnabled: () => t
+  };
+  return W ? Nt.forEach((n) => {
+    e[n] = (...r) => {
+      t && _t(() => {
+        h.console[n](`${De}[${n}]:`, ...r);
+      });
+    };
+  }) : Nt.forEach((n) => {
+    e[n] = () => {
+    };
+  }), e;
+}
+const p = Ce(), ke = /^(?:(\w+):)\/\/(?:(\w+)(?::(\w+)?)?@)([\w.-]+)(?::(\d+))?\/(.+)/;
+function $e(t) {
+  return t === "http" || t === "https";
+}
+function ht(t, e = !1) {
+  const { host: n, path: r, pass: s, port: i, projectId: o, protocol: a, publicKey: u } = t;
+  return `${a}://${u}${e && s ? `:${s}` : ""}@${n}${i ? `:${i}` : ""}/${r && `${r}/`}${o}`;
+}
+function we(t) {
+  const e = ke.exec(t);
+  if (!e) {
+    _t(() => {
+      console.error(`Invalid Sentry Dsn: ${t}`);
+    });
+    return;
+  }
+  const [n, r, s = "", i = "", o = "", a = ""] = e.slice(1);
+  let u = "", c = a;
+  const f = c.split("/");
+  if (f.length > 1 && (u = f.slice(0, -1).join("/"), c = f.pop()), c) {
+    const d = c.match(/^\d+/);
+    d && (c = d[0]);
+  }
+  return zt({ host: i, pass: s, path: u, projectId: c, port: o, protocol: n, publicKey: r });
+}
+function zt(t) {
+  return {
+    protocol: t.protocol,
+    publicKey: t.publicKey || "",
+    pass: t.pass || "",
+    host: t.host,
+    port: t.port || "",
+    path: t.path || "",
+    projectId: t.projectId
+  };
+}
+function Pe(t) {
+  if (!W)
+    return !0;
+  const { port: e, projectId: n, protocol: r } = t;
+  return ["protocol", "publicKey", "host", "projectId"].find((o) => t[o] ? !1 : (p.error(`Invalid Sentry Dsn: ${o} missing`), !0)) ? !1 : n.match(/^\d+$/) ? $e(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 Rr(t) {
+  const e = typeof t == "string" ? we(t) : zt(t);
+  if (!(!e || !Pe(e)))
+    return e;
+}
+function Dr(t, e, n) {
+  if (!(e in t))
+    return;
+  const r = t[e], s = n(r);
+  typeof s == "function" && xe(s, r), t[e] = s;
+}
+function D(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 {
+    W && p.log(`Failed to add non-enumerable property "${e}" to object`, t);
+  }
+}
+function xe(t, e) {
+  try {
+    const n = e.prototype || {};
+    t.prototype = e.prototype = n, D(t, "__sentry_original__", e);
+  } catch {
+  }
+}
+function Cr(t) {
+  return t.__sentry_original__;
+}
+function kr(t) {
+  return Object.keys(t).map((e) => `${encodeURIComponent(e)}=${encodeURIComponent(t[e])}`).join("&");
+}
+function qt(t) {
+  if (Se(t))
+    return {
+      message: t.message,
+      name: t.name,
+      stack: t.stack,
+      ...Rt(t)
+    };
+  if (Ee(t)) {
+    const e = {
+      type: t.type,
+      target: Ot(t.target),
+      currentTarget: Ot(t.currentTarget),
+      ...Rt(t)
+    };
+    return typeof CustomEvent < "u" && V(t, CustomEvent) && (e.detail = t.detail), e;
+  } else
+    return t;
+}
+function Ot(t) {
+  try {
+    return be(t) ? Oe(t) : Object.prototype.toString.call(t);
+  } catch {
+    return "<unknown>";
+  }
+}
+function Rt(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 $r(t, e = 40) {
+  const n = Object.keys(qt(t));
+  n.sort();
+  const r = n[0];
+  if (!r)
+    return "[object has no keys]";
+  if (r.length >= e)
+    return G(r, e);
+  for (let s = n.length; s > 0; s--) {
+    const i = n.slice(0, s).join(", ");
+    if (!(i.length > e))
+      return s === n.length ? i : G(i, e);
+  }
+  return "";
+}
+function m(t) {
+  return et(t, /* @__PURE__ */ new Map());
+}
+function et(t, e) {
+  if (Me(t)) {
+    const n = e.get(t);
+    if (n !== void 0)
+      return n;
+    const r = {};
+    e.set(t, r);
+    for (const s of Object.keys(t))
+      typeof t[s] < "u" && (r[s] = et(t[s], e));
+    return r;
+  }
+  if (Array.isArray(t)) {
+    const n = e.get(t);
+    if (n !== void 0)
+      return n;
+    const r = [];
+    return e.set(t, r), t.forEach((s) => {
+      r.push(et(s, e));
+    }), r;
+  }
+  return t;
+}
+function Me(t) {
+  if (!dt(t))
+    return !1;
+  try {
+    const e = Object.getPrototypeOf(t).constructor.name;
+    return !e || e === "Object";
+  } catch {
+    return !0;
+  }
+}
+const Vt = 50, Le = "?", Dt = /\(error: (.*)\)/, Ct = /captureMessage|captureException/;
+function Ue(...t) {
+  const e = t.sort((n, r) => n[0] - r[0]).map((n) => n[1]);
+  return (n, r = 0, s = 0) => {
+    const i = [], o = n.split(`
+`);
+    for (let a = r; a < o.length; a++) {
+      const u = o[a];
+      if (u.length > 1024)
+        continue;
+      const c = Dt.test(u) ? u.replace(Dt, "$1") : u;
+      if (!c.match(/\S*Error: /)) {
+        for (const f of e) {
+          const d = f(c);
+          if (d) {
+            i.push(d);
+            break;
+          }
+        }
+        if (i.length >= Vt + s)
+          break;
+      }
+    }
+    return je(i.slice(s));
+  };
+}
+function wr(t) {
+  return Array.isArray(t) ? Ue(...t) : t;
+}
+function je(t) {
+  if (!t.length)
+    return [];
+  const e = Array.from(t);
+  return /sentryWrapped/.test(K(e).function || "") && e.pop(), e.reverse(), Ct.test(K(e).function || "") && (e.pop(), Ct.test(K(e).function || "") && e.pop()), e.slice(0, Vt).map((n) => ({
+    ...n,
+    filename: n.filename || K(e).filename,
+    function: n.function || Le
+  }));
+}
+function K(t) {
+  return t[t.length - 1] || {};
+}
+const Z = "<anonymous>";
+function ve(t) {
+  try {
+    return !t || typeof t != "function" ? Z : t.name || Z;
+  } catch {
+    return Z;
+  }
+}
+function Pr(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 Wt = 1e3;
+function gt() {
+  return Date.now() / Wt;
+}
+function Fe() {
+  const { performance: t } = h;
+  if (!t || !t.now)
+    return gt;
+  const e = Date.now() - t.now(), n = t.timeOrigin == null ? e : t.timeOrigin;
+  return () => (n + t.now()) / Wt;
+}
+const x = Fe(), xr = (() => {
+  const { performance: t } = h;
+  if (!t || !t.now)
+    return;
+  const e = 3600 * 1e3, n = t.now(), r = Date.now(), s = t.timeOrigin ? Math.abs(t.timeOrigin + n - r) : e, i = s < e, o = t.timing && t.timing.navigationStart, u = typeof o == "number" ? Math.abs(o + n - r) : e, c = u < e;
+  return i || c ? s <= u ? t.timeOrigin : o : r;
+})();
+function Ge() {
+  const t = typeof WeakSet == "function", e = t ? /* @__PURE__ */ new WeakSet() : [];
+  function n(s) {
+    if (t)
+      return e.has(s) ? !0 : (e.add(s), !1);
+    for (let i = 0; i < e.length; i++)
+      if (e[i] === s)
+        return !0;
+    return e.push(s), !1;
+  }
+  function r(s) {
+    if (t)
+      e.delete(s);
+    else
+      for (let i = 0; i < e.length; i++)
+        if (e[i] === s) {
+          e.splice(i, 1);
+          break;
+        }
+  }
+  return [n, r];
+}
+function _() {
+  const t = h, e = t.crypto || t.msCrypto;
+  let n = () => Math.random() * 16;
+  try {
+    if (e && e.randomUUID)
+      return e.randomUUID().replace(/-/g, "");
+    e && e.getRandomValues && (n = () => {
+      const r = new Uint8Array(1);
+      return e.getRandomValues(r), r[0];
+    });
+  } catch {
+  }
+  return ("10000000100040008000" + 1e11).replace(
+    /[018]/g,
+    (r) => (
+      // eslint-disable-next-line no-bitwise
+      (r ^ (n() & 15) >> r / 4).toString(16)
+    )
+  );
+}
+function Xt(t) {
+  return t.exception && t.exception.values ? t.exception.values[0] : void 0;
+}
+function Mr(t) {
+  const { message: e, event_id: n } = t;
+  if (e)
+    return e;
+  const r = Xt(t);
+  return r ? r.type && r.value ? `${r.type}: ${r.value}` : r.type || r.value || n || "<unknown>" : n || "<unknown>";
+}
+function Lr(t, e, n) {
+  const r = t.exception = t.exception || {}, s = r.values = r.values || [], i = s[0] = s[0] || {};
+  i.value || (i.value = e || ""), i.type || (i.type = n || "Error");
+}
+function Be(t, e) {
+  const n = Xt(t);
+  if (!n)
+    return;
+  const r = { type: "generic", handled: !0 }, s = n.mechanism;
+  if (n.mechanism = { ...r, ...s, ...e }, e && "data" in e) {
+    const i = { ...s && s.data, ...e.data };
+    n.mechanism.data = i;
+  }
+}
+function Ur(t) {
+  if (t && t.__sentry_captured__)
+    return !0;
+  try {
+    D(t, "__sentry_captured__", !0);
+  } catch {
+  }
+  return !1;
+}
+function He(t) {
+  return Array.isArray(t) ? t : [t];
+}
+function R(t, e = 100, n = 1 / 0) {
+  try {
+    return nt("", t, e, n);
+  } catch (r) {
+    return { ERROR: `**non-serializable** (${r})` };
+  }
+}
+function Ye(t, e = 3, n = 100 * 1024) {
+  const r = R(t, e);
+  return qe(r) > n ? Ye(t, e - 1, n) : r;
+}
+function nt(t, e, n = 1 / 0, r = 1 / 0, s = Ge()) {
+  const [i, o] = s;
+  if (e == null || // this matches null and undefined -> eqeq not eqeqeq
+  ["number", "boolean", "string"].includes(typeof e) && !Number.isNaN(e))
+    return e;
+  const a = Je(t, e);
+  if (!a.startsWith("[object "))
+    return a;
+  if (e.__sentry_skip_normalization__)
+    return e;
+  const u = typeof e.__sentry_override_normalization_depth__ == "number" ? e.__sentry_override_normalization_depth__ : n;
+  if (u === 0)
+    return a.replace("object ", "");
+  if (i(e))
+    return "[Circular ~]";
+  const c = e;
+  if (c && typeof c.toJSON == "function")
+    try {
+      const g = c.toJSON();
+      return nt("", g, u - 1, r, s);
+    } catch {
+    }
+  const f = Array.isArray(e) ? [] : {};
+  let d = 0;
+  const l = qt(e);
+  for (const g in l) {
+    if (!Object.prototype.hasOwnProperty.call(l, g))
+      continue;
+    if (d >= r) {
+      f[g] = "[MaxProperties ~]";
+      break;
+    }
+    const $ = l[g];
+    f[g] = nt(g, $, u - 1, r, s), d++;
+  }
+  return o(e), f;
+}
+function Je(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 (Kt(e))
+      return "[VueViewModel]";
+    if (Ie(e))
+      return "[SyntheticEvent]";
+    if (typeof e == "number" && e !== e)
+      return "[NaN]";
+    if (typeof e == "function")
+      return `[Function: ${ve(e)}]`;
+    if (typeof e == "symbol")
+      return `[${String(e)}]`;
+    if (typeof e == "bigint")
+      return `[BigInt: ${String(e)}]`;
+    const n = Ke(e);
+    return /^HTML(\w*)Element$/.test(n) ? `[HTMLElement: ${n}]` : `[object ${n}]`;
+  } catch (n) {
+    return `**non-serializable** (${n})`;
+  }
+}
+function Ke(t) {
+  const e = Object.getPrototypeOf(t);
+  return e ? e.constructor.name : "null prototype";
+}
+function ze(t) {
+  return ~-encodeURI(t).split(/%..|./).length;
+}
+function qe(t) {
+  return ze(JSON.stringify(t));
+}
+var A;
+(function(t) {
+  t[t.PENDING = 0] = "PENDING";
+  const n = 1;
+  t[t.RESOLVED = n] = "RESOLVED";
+  const r = 2;
+  t[t.REJECTED = r] = "REJECTED";
+})(A || (A = {}));
+function jr(t) {
+  return new T((e) => {
+    e(t);
+  });
+}
+function vr(t) {
+  return new T((e, n) => {
+    n(t);
+  });
+}
+class T {
+  constructor(e) {
+    T.prototype.__init.call(this), T.prototype.__init2.call(this), T.prototype.__init3.call(this), T.prototype.__init4.call(this), this._state = A.PENDING, this._handlers = [];
+    try {
+      e(this._resolve, this._reject);
+    } catch (n) {
+      this._reject(n);
+    }
+  }
+  /** JSDoc */
+  then(e, n) {
+    return new T((r, s) => {
+      this._handlers.push([
+        !1,
+        (i) => {
+          if (!e)
+            r(i);
+          else
+            try {
+              r(e(i));
+            } catch (o) {
+              s(o);
+            }
+        },
+        (i) => {
+          if (!n)
+            s(i);
+          else
+            try {
+              r(n(i));
+            } catch (o) {
+              s(o);
+            }
+        }
+      ]), this._executeHandlers();
+    });
+  }
+  /** JSDoc */
+  catch(e) {
+    return this.then((n) => n, e);
+  }
+  /** JSDoc */
+  finally(e) {
+    return new T((n, r) => {
+      let s, i;
+      return this.then(
+        (o) => {
+          i = !1, s = o, e && e();
+        },
+        (o) => {
+          i = !0, s = o, e && e();
+        }
+      ).then(() => {
+        if (i) {
+          r(s);
+          return;
+        }
+        n(s);
+      });
+    });
+  }
+  /** JSDoc */
+  __init() {
+    this._resolve = (e) => {
+      this._setResult(A.RESOLVED, e);
+    };
+  }
+  /** JSDoc */
+  __init2() {
+    this._reject = (e) => {
+      this._setResult(A.REJECTED, e);
+    };
+  }
+  /** JSDoc */
+  __init3() {
+    this._setResult = (e, n) => {
+      if (this._state === A.PENDING) {
+        if (pt(n)) {
+          n.then(this._resolve, this._reject);
+          return;
+        }
+        this._state = e, this._value = n, this._executeHandlers();
+      }
+    };
+  }
+  /** JSDoc */
+  __init4() {
+    this._executeHandlers = () => {
+      if (this._state === A.PENDING)
+        return;
+      const e = this._handlers.slice();
+      this._handlers = [], e.forEach((n) => {
+        n[0] || (this._state === A.RESOLVED && n[1](this._value), this._state === A.REJECTED && n[2](this._value), n[0] = !0);
+      });
+    };
+  }
+}
+const Fr = "baggage", Qt = "sentry-", Ve = /^sentry-/, We = 8192;
+function Zt(t) {
+  const e = Xe(t);
+  if (!e)
+    return;
+  const n = Object.entries(e).reduce((r, [s, i]) => {
+    if (s.match(Ve)) {
+      const o = s.slice(Qt.length);
+      r[o] = i;
+    }
+    return r;
+  }, {});
+  if (Object.keys(n).length > 0)
+    return n;
+}
+function Gr(t) {
+  if (!t)
+    return;
+  const e = Object.entries(t).reduce(
+    (n, [r, s]) => (s && (n[`${Qt}${r}`] = s), n),
+    {}
+  );
+  return Qe(e);
+}
+function Xe(t) {
+  if (!(!t || !z(t) && !Array.isArray(t)))
+    return Array.isArray(t) ? t.reduce((e, n) => {
+      const r = kt(n);
+      return Object.entries(r).forEach(([s, i]) => {
+        e[s] = i;
+      }), e;
+    }, {}) : kt(t);
+}
+function kt(t) {
+  return t.split(",").map((e) => e.split("=").map((n) => decodeURIComponent(n.trim()))).reduce((e, [n, r]) => (n && r && (e[n] = r), e), {});
+}
+function Qe(t) {
+  if (Object.keys(t).length !== 0)
+    return Object.entries(t).reduce((e, [n, r], s) => {
+      const i = `${encodeURIComponent(n)}=${encodeURIComponent(r)}`, o = s === 0 ? i : `${e},${i}`;
+      return o.length > We ? (W && p.warn(
+        `Not adding key: ${n} with val: ${r} to baggage header due to exceeding baggage size limits.`
+      ), e) : o;
+    }, "");
+}
+const Ze = new RegExp(
+  "^[ \\t]*([0-9a-f]{32})?-?([0-9a-f]{16})?-?([01])?[ \\t]*$"
+  // whitespace
+);
+function tn(t) {
+  if (!t)
+    return;
+  const e = t.match(Ze);
+  if (!e)
+    return;
+  let n;
+  return e[3] === "1" ? n = !0 : e[3] === "0" && (n = !1), {
+    traceId: e[1],
+    parentSampled: n,
+    parentSpanId: e[2]
+  };
+}
+function Br(t, e) {
+  const n = tn(t), r = Zt(e), { traceId: s, parentSpanId: i, parentSampled: o } = n || {};
+  return n ? {
+    traceId: s || _(),
+    parentSpanId: i || _().substring(16),
+    spanId: _().substring(16),
+    sampled: o,
+    dsc: r || {}
+    // If we have traceparent data but no DSC it means we are not head of trace and we must freeze it
+  } : {
+    traceId: s || _(),
+    spanId: _().substring(16)
+  };
+}
+function en(t = _(), e = _().substring(16), n) {
+  let r = "";
+  return n !== void 0 && (r = n ? "-1" : "-0"), `${t}-${e}${r}`;
+}
+function mt(t, e = []) {
+  return [t, e];
+}
+function Hr(t, e) {
+  const [n, r] = t;
+  return [n, [...r, e]];
+}
+function Yr(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 rt(t) {
+  return h.__SENTRY__ && h.__SENTRY__.encodePolyfill ? h.__SENTRY__.encodePolyfill(t) : new TextEncoder().encode(t);
+}
+function Jr(t) {
+  const [e, n] = t;
+  let r = JSON.stringify(e);
+  function s(i) {
+    typeof r == "string" ? r = typeof i == "string" ? r + i : [rt(r), i] : r.push(typeof i == "string" ? rt(i) : i);
+  }
+  for (const i of n) {
+    const [o, a] = i;
+    if (s(`
+${JSON.stringify(o)}
+`), typeof a == "string" || a instanceof Uint8Array)
+      s(a);
+    else {
+      let u;
+      try {
+        u = JSON.stringify(a);
+      } catch {
+        u = JSON.stringify(R(a));
+      }
+      s(u);
+    }
+  }
+  return typeof r == "string" ? r : nn(r);
+}
+function nn(t) {
+  const e = t.reduce((s, i) => s + i.length, 0), n = new Uint8Array(e);
+  let r = 0;
+  for (const s of t)
+    n.set(s, r), r += s.length;
+  return n;
+}
+function rn(t) {
+  return [{
+    type: "span"
+  }, t];
+}
+function Kr(t) {
+  const e = typeof t.data == "string" ? rt(t.data) : t.data;
+  return [
+    m({
+      type: "attachment",
+      length: e.length,
+      filename: t.filename,
+      content_type: t.contentType,
+      attachment_type: t.attachmentType
+    }),
+    e
+  ];
+}
+const sn = {
+  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",
+  statsd: "metric_bucket"
+};
+function zr(t) {
+  return sn[t];
+}
+function te(t) {
+  if (!t || !t.sdk)
+    return;
+  const { name: e, version: n } = t.sdk;
+  return { name: e, version: n };
+}
+function on(t, e, n, r) {
+  const s = t.sdkProcessingMetadata && t.sdkProcessingMetadata.dynamicSamplingContext;
+  return {
+    event_id: t.event_id,
+    sent_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...e && { sdk: e },
+    ...!!n && r && { dsn: ht(r) },
+    ...s && {
+      trace: m({ ...s })
+    }
+  };
+}
+function $t() {
+  return {
+    traceId: _(),
+    spanId: _().substring(16)
+  };
+}
+const y = typeof __SENTRY_DEBUG__ > "u" || __SENTRY_DEBUG__;
+function U() {
+  return St(h), h;
+}
+function St(t) {
+  const e = t.__SENTRY__ = t.__SENTRY__ || {};
+  return e.version = e.version || B, e[B] = e[B] || {};
+}
+function an(t) {
+  const e = x(), n = {
+    sid: _(),
+    init: !0,
+    timestamp: e,
+    started: e,
+    duration: 0,
+    status: "ok",
+    errors: 0,
+    ignoreDuration: !1,
+    toJSON: () => un(n)
+  };
+  return t && X(n, t), n;
+}
+function X(t, e = {}) {
+  if (e.user && (!t.ipAddress && e.user.ip_address && (t.ipAddress = e.user.ip_address), !t.did && !e.did && (t.did = e.user.id || e.user.email || e.user.username)), t.timestamp = e.timestamp || x(), e.abnormal_mechanism && (t.abnormal_mechanism = e.abnormal_mechanism), e.ignoreDuration && (t.ignoreDuration = e.ignoreDuration), e.sid && (t.sid = e.sid.length === 32 ? e.sid : _()), 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 cn(t, e) {
+  let n = {};
+  e ? n = { status: e } : t.status === "ok" && (n = { status: "exited" }), X(t, n);
+}
+function un(t) {
+  return m({
+    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
+    }
+  });
+}
+const st = "_sentrySpan";
+function it(t, e) {
+  e ? D(t, st, e) : delete t[st];
+}
+function q(t) {
+  return t[st];
+}
+const fn = 100;
+class yt {
+  /** 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 */
+  /** Request Mode Session Status */
+  /** 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 = $t();
+  }
+  /**
+   * @inheritDoc
+   */
+  clone() {
+    const e = new yt();
+    return e._breadcrumbs = [...this._breadcrumbs], e._tags = { ...this._tags }, e._extra = { ...this._extra }, e._contexts = { ...this._contexts }, 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._requestSession = this._requestSession, e._attachments = [...this._attachments], e._sdkProcessingMetadata = { ...this._sdkProcessingMetadata }, e._propagationContext = { ...this._propagationContext }, e._client = this._client, e._lastEventId = this._lastEventId, it(e, q(this)), e;
+  }
+  /**
+   * @inheritDoc
+   */
+  setClient(e) {
+    this._client = e;
+  }
+  /**
+   * @inheritDoc
+   */
+  setLastEventId(e) {
+    this._lastEventId = e;
+  }
+  /**
+   * @inheritDoc
+   */
+  getClient() {
+    return this._client;
+  }
+  /**
+   * @inheritDoc
+   */
+  lastEventId() {
+    return this._lastEventId;
+  }
+  /**
+   * @inheritDoc
+   */
+  addScopeListener(e) {
+    this._scopeListeners.push(e);
+  }
+  /**
+   * @inheritDoc
+   */
+  addEventProcessor(e) {
+    return this._eventProcessors.push(e), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setUser(e) {
+    return this._user = e || {
+      email: void 0,
+      id: void 0,
+      ip_address: void 0,
+      username: void 0
+    }, this._session && X(this._session, { user: e }), this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  getUser() {
+    return this._user;
+  }
+  /**
+   * @inheritDoc
+   */
+  getRequestSession() {
+    return this._requestSession;
+  }
+  /**
+   * @inheritDoc
+   */
+  setRequestSession(e) {
+    return this._requestSession = e, this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setTags(e) {
+    return this._tags = {
+      ...this._tags,
+      ...e
+    }, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setTag(e, n) {
+    return this._tags = { ...this._tags, [e]: n }, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setExtras(e) {
+    return this._extra = {
+      ...this._extra,
+      ...e
+    }, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setExtra(e, n) {
+    return this._extra = { ...this._extra, [e]: n }, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setFingerprint(e) {
+    return this._fingerprint = e, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setLevel(e) {
+    return this._level = e, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setTransactionName(e) {
+    return this._transactionName = e, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setContext(e, n) {
+    return n === null ? delete this._contexts[e] : this._contexts[e] = n, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setSession(e) {
+    return e ? this._session = e : delete this._session, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  getSession() {
+    return this._session;
+  }
+  /**
+   * @inheritDoc
+   */
+  update(e) {
+    if (!e)
+      return this;
+    const n = typeof e == "function" ? e(this) : e, [r, s] = n instanceof C ? [n.getScopeData(), n.getRequestSession()] : dt(n) ? [e, e.requestSession] : [], { tags: i, extra: o, user: a, contexts: u, level: c, fingerprint: f = [], propagationContext: d } = r || {};
+    return this._tags = { ...this._tags, ...i }, this._extra = { ...this._extra, ...o }, this._contexts = { ...this._contexts, ...u }, a && Object.keys(a).length && (this._user = a), c && (this._level = c), f.length && (this._fingerprint = f), d && (this._propagationContext = d), s && (this._requestSession = s), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  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._requestSession = void 0, this._session = void 0, it(this, void 0), this._attachments = [], this._propagationContext = $t(), this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  addBreadcrumb(e, n) {
+    const r = typeof n == "number" ? n : fn;
+    if (r <= 0)
+      return this;
+    const s = {
+      timestamp: gt(),
+      ...e
+    }, i = this._breadcrumbs;
+    return i.push(s), this._breadcrumbs = i.length > r ? i.slice(-r) : i, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  getLastBreadcrumb() {
+    return this._breadcrumbs[this._breadcrumbs.length - 1];
+  }
+  /**
+   * @inheritDoc
+   */
+  clearBreadcrumbs() {
+    return this._breadcrumbs = [], this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  addAttachment(e) {
+    return this._attachments.push(e), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  clearAttachments() {
+    return this._attachments = [], this;
+  }
+  /** @inheritDoc */
+  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: q(this)
+    };
+  }
+  /**
+   * @inheritDoc
+   */
+  setSDKProcessingMetadata(e) {
+    return this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...e }, this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setPropagationContext(e) {
+    return this._propagationContext = e, this;
+  }
+  /**
+   * @inheritDoc
+   */
+  getPropagationContext() {
+    return this._propagationContext;
+  }
+  /**
+   * @inheritDoc
+   */
+  captureException(e, n) {
+    const r = n && n.event_id ? n.event_id : _();
+    if (!this._client)
+      return 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;
+  }
+  /**
+   * @inheritDoc
+   */
+  captureMessage(e, n, r) {
+    const s = r && r.event_id ? r.event_id : _();
+    if (!this._client)
+      return p.warn("No client configured on scope - will not capture message!"), s;
+    const i = new Error(e);
+    return this._client.captureMessage(
+      e,
+      n,
+      {
+        originalException: e,
+        syntheticException: i,
+        ...r,
+        event_id: s
+      },
+      this
+    ), s;
+  }
+  /**
+   * @inheritDoc
+   */
+  captureEvent(e, n) {
+    const r = n && n.event_id ? n.event_id : _();
+    return this._client ? (this._client.captureEvent(e, { ...n, event_id: r }, this), r) : (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);
+  }
+}
+const C = yt;
+function dn() {
+  return lt("defaultCurrentScope", () => new C());
+}
+function pn() {
+  return lt("defaultIsolationScope", () => new C());
+}
+class ln {
+  constructor(e, n) {
+    let r;
+    e ? r = e : r = new C();
+    let s;
+    n ? s = n : s = new C(), 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 pt(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 scope stack for domains or the process.
+   */
+  getStack() {
+    return this._stack;
+  }
+  /**
+   * 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.getStack().push({
+      client: this.getClient(),
+      scope: e
+    }), e;
+  }
+  /**
+   * Pop a scope from the stack.
+   */
+  _popScope() {
+    return this.getStack().length <= 1 ? !1 : !!this.getStack().pop();
+  }
+}
+function M() {
+  const t = U(), e = St(t);
+  return e.stack = e.stack || new ln(dn(), pn());
+}
+function _n(t) {
+  return M().withScope(t);
+}
+function hn(t, e) {
+  const n = M();
+  return n.withScope(() => (n.getStackTop().scope = t, e(t)));
+}
+function wt(t) {
+  return M().withScope(() => t(M().getIsolationScope()));
+}
+function gn() {
+  return {
+    withIsolationScope: wt,
+    withScope: _n,
+    withSetScope: hn,
+    withSetIsolationScope: (t, e) => wt(e),
+    getCurrentScope: () => M().getScope(),
+    getIsolationScope: () => M().getIsolationScope()
+  };
+}
+function J(t) {
+  const e = St(t);
+  return e.acs ? e.acs : gn();
+}
+function I() {
+  const t = U();
+  return J(t).getCurrentScope();
+}
+function j() {
+  const t = U();
+  return J(t).getIsolationScope();
+}
+function mn() {
+  return lt("globalScope", () => new C());
+}
+function ee(...t) {
+  const e = U(), n = J(e);
+  if (t.length === 2) {
+    const [r, s] = t;
+    return r ? n.withSetScope(r, s) : n.withScope(s);
+  }
+  return n.withScope(t[0]);
+}
+function N() {
+  return I().getClient();
+}
+const Sn = "_sentryMetrics";
+function ot(t) {
+  const e = t[Sn];
+  if (!e)
+    return;
+  const n = {};
+  for (const [, [r, s]] of e)
+    (n[r] || (n[r] = [])).push(m(s));
+  return n;
+}
+const Et = "sentry.source", ne = "sentry.sample_rate", at = "sentry.op", Y = "sentry.origin", qr = "sentry.idle_span_finish_reason", re = "sentry.measurement_unit", se = "sentry.measurement_value", yn = "sentry.profile_id", En = "sentry.exclusive_time", bn = 0, ie = 1, S = 2;
+function Tn(t) {
+  if (t < 400 && t >= 100)
+    return { code: ie };
+  if (t >= 400 && t < 500)
+    switch (t) {
+      case 401:
+        return { code: S, message: "unauthenticated" };
+      case 403:
+        return { code: S, message: "permission_denied" };
+      case 404:
+        return { code: S, message: "not_found" };
+      case 409:
+        return { code: S, message: "already_exists" };
+      case 413:
+        return { code: S, message: "failed_precondition" };
+      case 429:
+        return { code: S, message: "resource_exhausted" };
+      case 499:
+        return { code: S, message: "cancelled" };
+      default:
+        return { code: S, message: "invalid_argument" };
+    }
+  if (t >= 500 && t < 600)
+    switch (t) {
+      case 501:
+        return { code: S, message: "unimplemented" };
+      case 503:
+        return { code: S, message: "unavailable" };
+      case 504:
+        return { code: S, message: "deadline_exceeded" };
+      default:
+        return { code: S, message: "internal_error" };
+    }
+  return { code: S, message: "unknown_error" };
+}
+function Vr(t, e) {
+  t.setAttribute("http.response.status_code", e);
+  const n = Tn(e);
+  n.message !== "unknown_error" && t.setStatus(n);
+}
+const oe = 0, ae = 1;
+function In(t) {
+  const { spanId: e, traceId: n } = t.spanContext(), { data: r, op: s, parent_span_id: i, status: o, origin: a } = E(t);
+  return m({
+    parent_span_id: i,
+    span_id: e,
+    trace_id: n,
+    data: r,
+    op: s,
+    status: o,
+    origin: a
+  });
+}
+function Nn(t) {
+  const { spanId: e, traceId: n } = t.spanContext(), { parent_span_id: r } = E(t);
+  return m({ parent_span_id: r, span_id: e, trace_id: n });
+}
+function Wr(t) {
+  const { traceId: e, spanId: n } = t.spanContext(), r = v(t);
+  return en(e, n, r);
+}
+function P(t) {
+  return typeof t == "number" ? Pt(t) : Array.isArray(t) ? t[0] + t[1] / 1e9 : t instanceof Date ? Pt(t.getTime()) : x();
+}
+function Pt(t) {
+  return t > 9999999999 ? t / 1e3 : t;
+}
+function E(t) {
+  if (On(t))
+    return t.getSpanJSON();
+  try {
+    const { spanId: e, traceId: n } = t.spanContext();
+    if (An(t)) {
+      const { attributes: r, startTime: s, name: i, endTime: o, parentSpanId: a, status: u } = t;
+      return m({
+        span_id: e,
+        trace_id: n,
+        data: r,
+        description: i,
+        parent_span_id: a,
+        start_timestamp: P(s),
+        // This is [0,0] by default in OTEL, in which case we want to interpret this as no end time
+        timestamp: P(o) || void 0,
+        status: ce(u),
+        op: r[at],
+        origin: r[Y],
+        _metrics_summary: ot(t)
+      });
+    }
+    return {
+      span_id: e,
+      trace_id: n
+    };
+  } catch {
+    return {};
+  }
+}
+function An(t) {
+  const e = t;
+  return !!e.attributes && !!e.startTime && !!e.name && !!e.endTime && !!e.status;
+}
+function On(t) {
+  return typeof t.getSpanJSON == "function";
+}
+function v(t) {
+  const { traceFlags: e } = t.spanContext();
+  return e === ae;
+}
+function ce(t) {
+  if (!(!t || t.code === bn))
+    return t.code === ie ? "ok" : t.message || "unknown_error";
+}
+const k = "_sentryChildSpans", ct = "_sentryRootSpan";
+function ue(t, e) {
+  const n = t[ct] || t;
+  D(e, ct, n), t[k] ? t[k].add(e) : D(t, k, /* @__PURE__ */ new Set([e]));
+}
+function Xr(t, e) {
+  t[k] && t[k].delete(e);
+}
+function Rn(t) {
+  const e = /* @__PURE__ */ new Set();
+  function n(r) {
+    if (!e.has(r) && v(r)) {
+      e.add(r);
+      const s = r[k] ? Array.from(r[k]) : [];
+      for (const i of s)
+        n(i);
+    }
+  }
+  return n(t), Array.from(e);
+}
+function O(t) {
+  return t[ct] || t;
+}
+function ut() {
+  const t = U(), e = J(t);
+  return e.getActiveSpan ? e.getActiveSpan() : q(I());
+}
+const fe = "_sentryScope", de = "_sentryIsolationScope";
+function Dn(t, e, n) {
+  t && (D(t, de, n), D(t, fe, e));
+}
+function xt(t) {
+  return {
+    scope: t[fe],
+    isolationScope: t[de]
+  };
+}
+function pe(t) {
+  if (typeof __SENTRY_TRACING__ == "boolean" && !__SENTRY_TRACING__)
+    return !1;
+  const e = t || Cn();
+  return !!e && (e.enableTracing || "tracesSampleRate" in e || "tracesSampler" in e);
+}
+function Cn() {
+  const t = N();
+  return t && t.getOptions();
+}
+class bt {
+  constructor(e = {}) {
+    this._traceId = e.traceId || _(), this._spanId = e.spanId || _().substring(16);
+  }
+  /** @inheritdoc */
+  spanContext() {
+    return {
+      spanId: this._spanId,
+      traceId: this._traceId,
+      traceFlags: oe
+    };
+  }
+  /** @inheritdoc */
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  end(e) {
+  }
+  /** @inheritdoc */
+  setAttribute(e, n) {
+    return this;
+  }
+  /** @inheritdoc */
+  setAttributes(e) {
+    return this;
+  }
+  /** @inheritdoc */
+  setStatus(e) {
+    return this;
+  }
+  /** @inheritdoc */
+  updateName(e) {
+    return this;
+  }
+  /** @inheritdoc */
+  isRecording() {
+    return !1;
+  }
+  /** @inheritdoc */
+  addEvent(e, n, r) {
+    return this;
+  }
+}
+const Tt = "production", le = "_frozenDsc";
+function Mt(t, e) {
+  D(t, le, e);
+}
+function kn(t, e) {
+  const n = e.getOptions(), { publicKey: r } = e.getDsn() || {}, s = m({
+    environment: n.environment || Tt,
+    release: n.release,
+    public_key: r,
+    trace_id: t
+  });
+  return e.emit("createDsc", s), s;
+}
+function Q(t) {
+  const e = N();
+  if (!e)
+    return {};
+  const n = kn(E(t).trace_id || "", e), r = O(t), s = r[le];
+  if (s)
+    return s;
+  const i = r.spanContext().traceState, o = i && i.get("sentry.dsc"), a = o && Zt(o);
+  if (a)
+    return a;
+  const u = E(r), c = u.data || {}, f = c[ne];
+  f != null && (n.sample_rate = `${f}`);
+  const d = c[Et], l = u.description;
+  return d !== "url" && l && (n.transaction = l), n.sampled = String(v(r)), e.emit("createDsc", n, r), n;
+}
+function $n(t) {
+  if (!y) return;
+  const { description: e = "< unknown name >", op: n = "< unknown op >", parent_span_id: r } = E(t), { spanId: s } = t.spanContext(), i = v(t), o = O(t), a = o === t, u = `[Tracing] Starting ${i ? "sampled" : "unsampled"} ${a ? "root " : ""}span`, c = [`op: ${n}`, `name: ${e}`, `ID: ${s}`];
+  if (r && c.push(`parent ID: ${r}`), !a) {
+    const { op: f, description: d } = E(o);
+    c.push(`root ID: ${o.spanContext().spanId}`), f && c.push(`root op: ${f}`), d && c.push(`root description: ${d}`);
+  }
+  p.log(`${u}
+  ${c.join(`
+  `)}`);
+}
+function wn(t) {
+  if (!y) return;
+  const { description: e = "< unknown name >", op: n = "< unknown op >" } = E(t), { spanId: r } = t.spanContext(), i = O(t) === t, o = `[Tracing] Finishing "${n}" ${i ? "root " : ""}span "${e}" with ID ${r}`;
+  p.log(o);
+}
+function Pn(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) {
+    y && p.warn(
+      `[Tracing] Given sample rate is invalid. Sample rate must be a boolean or a number between 0 and 1. Got ${JSON.stringify(
+        t
+      )} of type ${JSON.stringify(typeof t)}.`
+    );
+    return;
+  }
+  return e;
+}
+function xn(t, e) {
+  if (!pe(t))
+    return [!1];
+  let n;
+  typeof t.tracesSampler == "function" ? n = t.tracesSampler(e) : e.parentSampled !== void 0 ? n = e.parentSampled : typeof t.tracesSampleRate < "u" ? n = t.tracesSampleRate : n = 1;
+  const r = Pn(n);
+  return r === void 0 ? (y && p.warn("[Tracing] Discarding transaction because of invalid sample rate."), [!1]) : r ? Math.random() < r ? [!0, r] : (y && p.log(
+    `[Tracing] Discarding transaction because it's not included in the random sample (sampling rate = ${Number(
+      n
+    )})`
+  ), [!1, r]) : (y && p.log(
+    `[Tracing] Discarding transaction because ${typeof t.tracesSampler == "function" ? "tracesSampler returned 0 or false" : "a negative sampling decision was inherited or tracesSampleRate is set to 0"}`
+  ), [!1, r]);
+}
+function Mn(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 Qr(t, e, n, r) {
+  const s = te(n), i = {
+    sent_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...s && { sdk: s },
+    ...!!r && e && { dsn: ht(e) }
+  }, o = "aggregates" in t ? [{ type: "sessions" }, t] : [{ type: "session" }, t.toJSON()];
+  return mt(i, [o]);
+}
+function Zr(t, e, n, r) {
+  const s = te(n), i = t.type && t.type !== "replay_event" ? t.type : "event";
+  Mn(t, n && n.sdk);
+  const o = on(t, s, r, e);
+  return delete t.sdkProcessingMetadata, mt(o, [[{ type: i }, t]]);
+}
+function Ln(t, e) {
+  function n(f) {
+    return !!f.trace_id && !!f.public_key;
+  }
+  const r = Q(t[0]), s = e && e.getDsn(), i = e && e.getOptions().tunnel, o = {
+    sent_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...n(r) && { trace: r },
+    ...!!i && s && { dsn: ht(s) }
+  }, a = e && e.getOptions().beforeSendSpan, u = a ? (f) => a(E(f)) : (f) => E(f), c = [];
+  for (const f of t) {
+    const d = u(f);
+    d && c.push(rn(d));
+  }
+  return mt(o, c);
+}
+function ts(t, e, n) {
+  const r = ut(), s = r && O(r);
+  s && s.addEvent(t, {
+    [se]: e,
+    [re]: n
+  });
+}
+function Lt(t) {
+  if (!t || t.length === 0)
+    return;
+  const e = {};
+  return t.forEach((n) => {
+    const r = n.attributes || {}, s = r[re], i = r[se];
+    typeof s == "string" && typeof i == "number" && (e[n.name] = { value: i, unit: s });
+  }), e;
+}
+const Ut = 1e3;
+class It {
+  /** Epoch timestamp in seconds when the span started. */
+  /** Epoch timestamp in seconds when the span ended. */
+  /** Internal keeper of the status */
+  /** The timed events added to this span. */
+  /** if true, treat span as a standalone span (not part of a transaction) */
+  /**
+   * You should never call the constructor manually, always use `Sentry.startSpan()`
+   * or other span methods.
+   * @internal
+   * @hideconstructor
+   * @hidden
+   */
+  constructor(e = {}) {
+    this._traceId = e.traceId || _(), this._spanId = e.spanId || _().substring(16), this._startTime = e.startTimestamp || x(), this._attributes = {}, this.setAttributes({
+      [Y]: "manual",
+      [at]: e.op,
+      ...e.attributes
+    }), this._name = e.name, e.parentSpanId && (this._parentSpanId = e.parentSpanId), "sampled" in e && (this._sampled = e.sampled), e.endTimestamp && (this._endTime = e.endTimestamp), this._events = [], this._isStandaloneSpan = e.isStandalone, this._endTime && this._onSpanEnded();
+  }
+  /** @inheritdoc */
+  spanContext() {
+    const { _spanId: e, _traceId: n, _sampled: r } = this;
+    return {
+      spanId: e,
+      traceId: n,
+      traceFlags: r ? ae : oe
+    };
+  }
+  /** @inheritdoc */
+  setAttribute(e, n) {
+    n === void 0 ? delete this._attributes[e] : this._attributes[e] = n;
+  }
+  /** @inheritdoc */
+  setAttributes(e) {
+    Object.keys(e).forEach((n) => this.setAttribute(n, e[n]));
+  }
+  /**
+   * This should generally not be used,
+   * but we need it for browser tracing where we want to adjust the start time afterwards.
+   * USE THIS WITH CAUTION!
+   *
+   * @hidden
+   * @internal
+   */
+  updateStartTime(e) {
+    this._startTime = P(e);
+  }
+  /**
+   * @inheritDoc
+   */
+  setStatus(e) {
+    return this._status = e, this;
+  }
+  /**
+   * @inheritDoc
+   */
+  updateName(e) {
+    return this._name = e, this;
+  }
+  /** @inheritdoc */
+  end(e) {
+    this._endTime || (this._endTime = P(e), wn(this), this._onSpanEnded());
+  }
+  /**
+   * Get JSON representation of this span.
+   *
+   * @hidden
+   * @internal This method is purely for internal purposes and should not be used outside
+   * of SDK code. If you need to get a JSON representation of a span,
+   * use `spanToJSON(span)` instead.
+   */
+  getSpanJSON() {
+    return m({
+      data: this._attributes,
+      description: this._name,
+      op: this._attributes[at],
+      parent_span_id: this._parentSpanId,
+      span_id: this._spanId,
+      start_timestamp: this._startTime,
+      status: ce(this._status),
+      timestamp: this._endTime,
+      trace_id: this._traceId,
+      origin: this._attributes[Y],
+      _metrics_summary: ot(this),
+      profile_id: this._attributes[yn],
+      exclusive_time: this._attributes[En],
+      measurements: Lt(this._events),
+      is_segment: this._isStandaloneSpan && O(this) === this || void 0,
+      segment_id: this._isStandaloneSpan ? O(this).spanContext().spanId : void 0
+    });
+  }
+  /** @inheritdoc */
+  isRecording() {
+    return !this._endTime && !!this._sampled;
+  }
+  /**
+   * @inheritdoc
+   */
+  addEvent(e, n, r) {
+    y && p.log("[Tracing] Adding an event to span:", e);
+    const s = jt(n) ? n : r || x(), i = jt(n) ? {} : n || {}, o = {
+      name: e,
+      time: P(s),
+      attributes: i
+    };
+    return this._events.push(o), this;
+  }
+  /**
+   * This method should generally not be used,
+   * but for now we need a way to publicly check if the `_isStandaloneSpan` flag is set.
+   * USE THIS WITH CAUTION!
+   * @internal
+   * @hidden
+   * @experimental
+   */
+  isStandaloneSpan() {
+    return !!this._isStandaloneSpan;
+  }
+  /** Emit `spanEnd` when the span is ended. */
+  _onSpanEnded() {
+    const e = N();
+    if (e && e.emit("spanEnd", this), !(this._isStandaloneSpan || this === O(this)))
+      return;
+    if (this._isStandaloneSpan) {
+      this._sampled ? jn(Ln([this], e)) : (y && p.log("[Tracing] Discarding standalone span because its trace was not chosen to be sampled."), e && e.recordDroppedEvent("sample_rate", "span"));
+      return;
+    }
+    const r = this._convertSpanToTransaction();
+    r && (xt(this).scope || I()).captureEvent(r);
+  }
+  /**
+   * Finish the transaction & prepare the event to send to Sentry.
+   */
+  _convertSpanToTransaction() {
+    if (!vt(E(this)))
+      return;
+    this._name || (y && p.warn("Transaction has no name, falling back to `<unlabeled transaction>`."), this._name = "<unlabeled transaction>");
+    const { scope: e, isolationScope: n } = xt(this), s = (e || I()).getClient() || N();
+    if (this._sampled !== !0) {
+      y && p.log("[Tracing] Discarding transaction because its trace was not chosen to be sampled."), s && s.recordDroppedEvent("sample_rate", "transaction");
+      return;
+    }
+    const o = Rn(this).filter((d) => d !== this && !Un(d)).map((d) => E(d)).filter(vt), a = this._attributes[Et], u = {
+      contexts: {
+        trace: In(this)
+      },
+      spans: (
+        // spans.sort() mutates the array, but `spans` is already a copy so we can safely do this here
+        // we do not use spans anymore after this point
+        o.length > Ut ? o.sort((d, l) => d.start_timestamp - l.start_timestamp).slice(0, Ut) : o
+      ),
+      start_timestamp: this._startTime,
+      timestamp: this._endTime,
+      transaction: this._name,
+      type: "transaction",
+      sdkProcessingMetadata: {
+        capturedSpanScope: e,
+        capturedSpanIsolationScope: n,
+        ...m({
+          dynamicSamplingContext: Q(this)
+        })
+      },
+      _metrics_summary: ot(this),
+      ...a && {
+        transaction_info: {
+          source: a
+        }
+      }
+    }, c = Lt(this._events);
+    return c && Object.keys(c).length && (y && p.log(
+      "[Measurements] Adding measurements to transaction event",
+      JSON.stringify(c, void 0, 2)
+    ), u.measurements = c), u;
+  }
+}
+function jt(t) {
+  return t && typeof t == "number" || t instanceof Date || Array.isArray(t);
+}
+function vt(t) {
+  return !!t.start_timestamp && !!t.timestamp && !!t.span_id && !!t.trace_id;
+}
+function Un(t) {
+  return t instanceof It && t.isStandaloneSpan();
+}
+function jn(t) {
+  const e = N();
+  if (!e)
+    return;
+  const n = t[1];
+  if (!n || n.length === 0) {
+    e.recordDroppedEvent("before_send", "span");
+    return;
+  }
+  const r = e.getTransport();
+  r && r.send(t).then(null, (s) => {
+    y && p.error("Error while sending span:", s);
+  });
+}
+const _e = "__SENTRY_SUPPRESS_TRACING__";
+function Ft(t) {
+  const e = he();
+  if (e.startInactiveSpan)
+    return e.startInactiveSpan(t);
+  const n = Gn(t), { forceTransaction: r, parentSpan: s } = t;
+  return (t.scope ? (o) => ee(t.scope, o) : s ? (o) => vn(s, o) : (o) => o())(() => {
+    const o = I(), a = Hn(o);
+    return t.onlyIfParent && !a ? new bt() : Fn({
+      parentSpan: a,
+      spanArguments: n,
+      forceTransaction: r,
+      scope: o
+    });
+  });
+}
+function vn(t, e) {
+  const n = he();
+  return n.withActiveSpan ? n.withActiveSpan(t, e) : ee((r) => (it(r, t || void 0), e(r)));
+}
+function Fn({
+  parentSpan: t,
+  spanArguments: e,
+  forceTransaction: n,
+  scope: r
+}) {
+  if (!pe())
+    return new bt();
+  const s = j();
+  let i;
+  if (t && !n)
+    i = Bn(t, r, e), ue(t, i);
+  else if (t) {
+    const o = Q(t), { traceId: a, spanId: u } = t.spanContext(), c = v(t);
+    i = Gt(
+      {
+        traceId: a,
+        parentSpanId: u,
+        ...e
+      },
+      r,
+      c
+    ), Mt(i, o);
+  } else {
+    const {
+      traceId: o,
+      dsc: a,
+      parentSpanId: u,
+      sampled: c
+    } = {
+      ...s.getPropagationContext(),
+      ...r.getPropagationContext()
+    };
+    i = Gt(
+      {
+        traceId: o,
+        parentSpanId: u,
+        ...e
+      },
+      r,
+      c
+    ), a && Mt(i, a);
+  }
+  return $n(i), Dn(i, r, s), i;
+}
+function Gn(t) {
+  const n = {
+    isStandalone: (t.experimental || {}).standalone,
+    ...t
+  };
+  if (t.startTime) {
+    const r = { ...n };
+    return r.startTimestamp = P(t.startTime), delete r.startTime, r;
+  }
+  return n;
+}
+function he() {
+  const t = U();
+  return J(t);
+}
+function Gt(t, e, n) {
+  const r = N(), s = r && r.getOptions() || {}, { name: i = "", attributes: o } = t, [a, u] = e.getScopeData().sdkProcessingMetadata[_e] ? [!1] : xn(s, {
+    name: i,
+    parentSampled: n,
+    attributes: o,
+    transactionContext: {
+      name: i,
+      parentSampled: n
+    }
+  }), c = new It({
+    ...t,
+    attributes: {
+      [Et]: "custom",
+      ...t.attributes
+    },
+    sampled: a
+  });
+  return u !== void 0 && c.setAttribute(ne, u), r && r.emit("spanStart", c), c;
+}
+function Bn(t, e, n) {
+  const { spanId: r, traceId: s } = t.spanContext(), i = e.getScopeData().sdkProcessingMetadata[_e] ? !1 : v(t), o = i ? new It({
+    ...n,
+    parentSpanId: r,
+    traceId: s,
+    sampled: i
+  }) : new bt({ traceId: s });
+  ue(t, o);
+  const a = N();
+  return a && (a.emit("spanStart", o), n.endTimestamp && a.emit("spanEnd", o)), o;
+}
+function Hn(t) {
+  const e = q(t);
+  if (!e)
+    return;
+  const n = N();
+  return (n ? n.getOptions() : {}).parentSpanIsAlwaysRootSpan ? O(e) : e;
+}
+function ft(t, e, n, r = 0) {
+  return new T((s, i) => {
+    const o = t[r];
+    if (e === null || typeof o != "function")
+      s(e);
+    else {
+      const a = o({ ...e }, n);
+      y && o.id && a === null && p.log(`Event processor "${o.id}" dropped event`), pt(a) ? a.then((u) => ft(t, u, n, r + 1).then(s)).then(null, i) : ft(t, a, n, r + 1).then(s).then(null, i);
+    }
+  });
+}
+function Yn(t, e) {
+  const { fingerprint: n, span: r, breadcrumbs: s, sdkProcessingMetadata: i } = e;
+  Jn(t, e), r && qn(t, r), Vn(t, n), Kn(t, s), zn(t, i);
+}
+function Bt(t, e) {
+  const {
+    extra: n,
+    tags: r,
+    user: s,
+    contexts: i,
+    level: o,
+    sdkProcessingMetadata: a,
+    breadcrumbs: u,
+    fingerprint: c,
+    eventProcessors: f,
+    attachments: d,
+    propagationContext: l,
+    transactionName: g,
+    span: $
+  } = e;
+  F(t, "extra", n), F(t, "tags", r), F(t, "user", s), F(t, "contexts", i), F(t, "sdkProcessingMetadata", a), o && (t.level = o), g && (t.transactionName = g), $ && (t.span = $), u.length && (t.breadcrumbs = [...t.breadcrumbs, ...u]), c.length && (t.fingerprint = [...t.fingerprint, ...c]), f.length && (t.eventProcessors = [...t.eventProcessors, ...f]), d.length && (t.attachments = [...t.attachments, ...d]), t.propagationContext = { ...t.propagationContext, ...l };
+}
+function F(t, e, n) {
+  if (n && Object.keys(n).length) {
+    t[e] = { ...t[e] };
+    for (const r in n)
+      Object.prototype.hasOwnProperty.call(n, r) && (t[e][r] = n[r]);
+  }
+}
+function Jn(t, e) {
+  const { extra: n, tags: r, user: s, contexts: i, level: o, transactionName: a } = e, u = m(n);
+  u && Object.keys(u).length && (t.extra = { ...u, ...t.extra });
+  const c = m(r);
+  c && Object.keys(c).length && (t.tags = { ...c, ...t.tags });
+  const f = m(s);
+  f && Object.keys(f).length && (t.user = { ...f, ...t.user });
+  const d = m(i);
+  d && Object.keys(d).length && (t.contexts = { ...d, ...t.contexts }), o && (t.level = o), a && t.type !== "transaction" && (t.transaction = a);
+}
+function Kn(t, e) {
+  const n = [...t.breadcrumbs || [], ...e];
+  t.breadcrumbs = n.length ? n : void 0;
+}
+function zn(t, e) {
+  t.sdkProcessingMetadata = {
+    ...t.sdkProcessingMetadata,
+    ...e
+  };
+}
+function qn(t, e) {
+  t.contexts = {
+    trace: Nn(e),
+    ...t.contexts
+  }, t.sdkProcessingMetadata = {
+    dynamicSamplingContext: Q(e),
+    ...t.sdkProcessingMetadata
+  };
+  const n = O(e), r = E(n).description;
+  r && !t.transaction && t.type === "transaction" && (t.transaction = r);
+}
+function Vn(t, e) {
+  t.fingerprint = t.fingerprint ? He(t.fingerprint) : [], e && (t.fingerprint = t.fingerprint.concat(e)), t.fingerprint && !t.fingerprint.length && delete t.fingerprint;
+}
+function es(t, e, n, r, s, i) {
+  const { normalizeDepth: o = 3, normalizeMaxBreadth: a = 1e3 } = t, u = {
+    ...e,
+    event_id: e.event_id || n.event_id || _(),
+    timestamp: e.timestamp || gt()
+  }, c = n.integrations || t.integrations.map((b) => b.name);
+  Wn(u, t), Zn(u, c), e.type === void 0 && Xn(u, t.stackParser);
+  const f = er(r, n.captureContext);
+  n.mechanism && Be(u, n.mechanism);
+  const d = s ? s.getEventProcessors() : [], l = mn().getScopeData();
+  if (i) {
+    const b = i.getScopeData();
+    Bt(l, b);
+  }
+  if (f) {
+    const b = f.getScopeData();
+    Bt(l, b);
+  }
+  const g = [...n.attachments || [], ...l.attachments];
+  g.length && (n.attachments = g), Yn(u, l);
+  const $ = [
+    ...d,
+    // Run scope event processors _after_ all other processors
+    ...l.eventProcessors
+  ];
+  return ft($, u, n).then((b) => (b && Qn(b), typeof o == "number" && o > 0 ? tr(b, o, a) : b));
+}
+function Wn(t, e) {
+  const { environment: n, release: r, dist: s, maxValueLength: i = 250 } = e;
+  "environment" in t || (t.environment = "environment" in e ? n : Tt), t.release === void 0 && r !== void 0 && (t.release = r), t.dist === void 0 && s !== void 0 && (t.dist = s), t.message && (t.message = G(t.message, i));
+  const o = t.exception && t.exception.values && t.exception.values[0];
+  o && o.value && (o.value = G(o.value, i));
+  const a = t.request;
+  a && a.url && (a.url = G(a.url, i));
+}
+const Ht = /* @__PURE__ */ new WeakMap();
+function Xn(t, e) {
+  const n = h._sentryDebugIds;
+  if (!n)
+    return;
+  let r;
+  const s = Ht.get(e);
+  s ? r = s : (r = /* @__PURE__ */ new Map(), Ht.set(e, r));
+  const i = Object.entries(n).reduce(
+    (o, [a, u]) => {
+      let c;
+      const f = r.get(a);
+      f ? c = f : (c = e(a), r.set(a, c));
+      for (let d = c.length - 1; d >= 0; d--) {
+        const l = c[d];
+        if (l.filename) {
+          o[l.filename] = u;
+          break;
+        }
+      }
+      return o;
+    },
+    {}
+  );
+  try {
+    t.exception.values.forEach((o) => {
+      o.stacktrace.frames.forEach((a) => {
+        a.filename && (a.debug_id = i[a.filename]);
+      });
+    });
+  } catch {
+  }
+}
+function Qn(t) {
+  const e = {};
+  try {
+    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);
+      });
+    });
+  } catch {
+  }
+  if (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 Zn(t, e) {
+  e.length > 0 && (t.sdk = t.sdk || {}, t.sdk.integrations = [...t.sdk.integrations || [], ...e]);
+}
+function tr(t, e, n) {
+  if (!t)
+    return null;
+  const r = {
+    ...t,
+    ...t.breadcrumbs && {
+      breadcrumbs: t.breadcrumbs.map((s) => ({
+        ...s,
+        ...s.data && {
+          data: R(s.data, e, n)
+        }
+      }))
+    },
+    ...t.user && {
+      user: R(t.user, e, n)
+    },
+    ...t.contexts && {
+      contexts: R(t.contexts, e, n)
+    },
+    ...t.extra && {
+      extra: R(t.extra, e, n)
+    }
+  };
+  return t.contexts && t.contexts.trace && r.contexts && (r.contexts.trace = t.contexts.trace, t.contexts.trace.data && (r.contexts.trace.data = R(t.contexts.trace.data, e, n))), t.spans && (r.spans = t.spans.map((s) => ({
+    ...s,
+    ...s.data && {
+      data: R(s.data, e, n)
+    }
+  }))), r;
+}
+function er(t, e) {
+  if (!e)
+    return t;
+  const n = t ? t.clone() : new C();
+  return n.update(e), n;
+}
+function nr(t) {
+  if (t)
+    return rr(t) ? { captureContext: t } : ir(t) ? {
+      captureContext: t
+    } : t;
+}
+function rr(t) {
+  return t instanceof C || typeof t == "function";
+}
+const sr = [
+  "user",
+  "level",
+  "extra",
+  "contexts",
+  "tags",
+  "fingerprint",
+  "requestSession",
+  "propagationContext"
+];
+function ir(t) {
+  return Object.keys(t).some((e) => sr.includes(e));
+}
+function or(t, e) {
+  return I().captureException(t, nr(e));
+}
+function ns(t, e) {
+  return I().captureEvent(t, e);
+}
+function rs(t, e) {
+  j().setContext(t, e);
+}
+function ss(t) {
+  j().addEventProcessor(t);
+}
+function is(t) {
+  const e = N(), n = j(), r = I(), { release: s, environment: i = Tt } = e && e.getOptions() || {}, { userAgent: o } = h.navigator || {}, a = an({
+    release: s,
+    environment: i,
+    user: r.getUser() || n.getUser(),
+    ...o && { userAgent: o },
+    ...t
+  }), u = n.getSession();
+  return u && u.status === "ok" && X(u, { status: "exited" }), ge(), n.setSession(a), r.setSession(a), a;
+}
+function ge() {
+  const t = j(), e = I(), n = e.getSession() || t.getSession();
+  n && cn(n), me(), t.setSession(), e.setSession();
+}
+function me() {
+  const t = j(), e = I(), n = N(), r = e.getSession() || t.getSession();
+  r && n && n.captureSession(r);
+}
+function os(t = !1) {
+  if (t) {
+    ge();
+    return;
+  }
+  me();
+}
+const ar = ["activate", "mount", "update"], cr = typeof __SENTRY_DEBUG__ > "u" || __SENTRY_DEBUG__, ur = /(?:^|[-_])(\w)/g, fr = (t) => t.replace(ur, (e) => e.toUpperCase()).replace(/[-_]/g, ""), dr = "<Root>", tt = "<Anonymous>", pr = (t, e) => t.repeat(e), H = (t, e) => {
+  if (!t)
+    return tt;
+  if (t.$root === t)
+    return dr;
+  if (!t.$options)
+    return tt;
+  const n = t.$options;
+  let r = n.name || n._componentTag;
+  const s = n.__file;
+  if (!r && s) {
+    const i = s.match(/([^/\\]+)\.vue$/);
+    i && (r = i[1]);
+  }
+  return (r ? `<${fr(r)}>` : tt) + (s && e !== !1 ? ` at ${s}` : "");
+}, lr = (t) => {
+  if (t && (t._isVue || t.__isVue) && t.$parent) {
+    const e = [];
+    let n = 0;
+    for (; t; ) {
+      if (e.length > 0) {
+        const s = e[e.length - 1];
+        if (s.constructor === t.constructor) {
+          n++, t = t.$parent;
+          continue;
+        } else n > 0 && (e[e.length - 1] = [s, n], n = 0);
+      }
+      e.push(t), t = t.$parent;
+    }
+    return `
+
+found in
+
+${e.map(
+      (s, i) => `${(i === 0 ? "---> " : pr(" ", 5 + i * 2)) + (Array.isArray(s) ? `${H(s[0])}... (${s[1]} recursive calls)` : H(s))}`
+    ).join(`
+`)}`;
+  }
+  return `
+
+(found in ${H(t)})`;
+}, as = (t, e) => {
+  const { errorHandler: n, warnHandler: r, silent: s } = t.config;
+  t.config.errorHandler = (i, o, a) => {
+    const u = H(o, !1), c = o ? lr(o) : "", f = {
+      componentName: u,
+      lifecycleHook: a,
+      trace: c
+    };
+    if (e.attachProps && o && (o.$options && o.$options.propsData ? f.propsData = o.$options.propsData : o.$props && (f.propsData = o.$props)), setTimeout(() => {
+      or(i, {
+        captureContext: { contexts: { vue: f } },
+        mechanism: { handled: !1 }
+      });
+    }), typeof n == "function" && n.call(t, i, o, a), e.logErrors) {
+      const d = typeof console < "u", l = `Error in ${a}: "${i && i.toString()}"`;
+      r ? r.call(null, l, o, c) : d && !s && _t(() => {
+        console.error(`[Vue warn]: ${l}${c}`);
+      });
+    }
+  };
+}, Yt = "ui.vue", _r = {
+  activate: ["activated", "deactivated"],
+  create: ["beforeCreate", "created"],
+  // Vue 3
+  unmount: ["beforeUnmount", "unmounted"],
+  // Vue 2
+  destroy: ["beforeDestroy", "destroyed"],
+  mount: ["beforeMount", "mounted"],
+  update: ["beforeUpdate", "updated"]
+};
+function hr(t, e, n) {
+  t.$_sentryRootSpanTimer && clearTimeout(t.$_sentryRootSpanTimer), t.$_sentryRootSpanTimer = setTimeout(() => {
+    t.$root && t.$root.$_sentryRootSpan && (t.$root.$_sentryRootSpan.end(e), t.$root.$_sentryRootSpan = void 0);
+  }, n);
+}
+const cs = (t) => {
+  const e = (t.hooks || []).concat(ar).filter((r, s, i) => i.indexOf(r) === s), n = {};
+  for (const r of e) {
+    const s = _r[r];
+    if (!s) {
+      cr && p.warn(`Unknown hook: ${r}`);
+      continue;
+    }
+    for (const i of s)
+      n[i] = function() {
+        const o = this.$root === this;
+        o && ut() && (this.$_sentryRootSpan = this.$_sentryRootSpan || Ft({
+          name: "Application Render",
+          op: `${Yt}.render`,
+          attributes: {
+            [Y]: "auto.ui.vue"
+          }
+        }));
+        const a = H(this, !1), u = Array.isArray(t.trackComponents) ? t.trackComponents.indexOf(a) > -1 : t.trackComponents;
+        if (!(!o && !u))
+          if (this.$_sentrySpans = this.$_sentrySpans || {}, i == s[0]) {
+            if (this.$root && this.$root.$_sentryRootSpan || ut()) {
+              const f = this.$_sentrySpans[r];
+              f && f.end(), this.$_sentrySpans[r] = Ft({
+                name: `Vue <${a}>`,
+                op: `${Yt}.${r}`,
+                attributes: {
+                  [Y]: "auto.ui.vue"
+                }
+              });
+            }
+          } else {
+            const c = this.$_sentrySpans[r];
+            if (!c) return;
+            c.end(), hr(this, x(), t.timeout);
+          }
+      };
+  }
+  return n;
+};
+var us = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function fs(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+export {
+  dt as $,
+  Rn as A,
+  E as B,
+  Nt as C,
+  W as D,
+  qr as E,
+  Xr as F,
+  h as G,
+  Ft as H,
+  kr as I,
+  He as J,
+  Rr as K,
+  _ as L,
+  Ur as M,
+  br as N,
+  X as O,
+  Zr as P,
+  Hr as Q,
+  Kr as R,
+  T as S,
+  Qr as T,
+  es as U,
+  m as V,
+  kn as W,
+  j as X,
+  Pn as Y,
+  pt as Z,
+  it as _,
+  cs as a,
+  ye as a0,
+  _t as a1,
+  Yr as a2,
+  zr as a3,
+  Jr as a4,
+  B as a5,
+  Cr as a6,
+  Mr as a7,
+  Ir as a8,
+  Pr as a9,
+  En as aA,
+  re as aB,
+  se as aC,
+  Ue as aD,
+  Le as aE,
+  Tr as aF,
+  ns as aG,
+  Nr as aH,
+  wr as aI,
+  is as aJ,
+  os as aK,
+  Et as aL,
+  ss as aM,
+  rs as aN,
+  R as aO,
+  on as aP,
+  te as aQ,
+  Br as aR,
+  v as aS,
+  Ar as aT,
+  $t as aU,
+  cr as aV,
+  ar as aW,
+  Y as aa,
+  at as ab,
+  Wr as ac,
+  en as ad,
+  Gr as ae,
+  Q as af,
+  Fr as ag,
+  Vr as ah,
+  xe as ai,
+  ee as aj,
+  Lr as ak,
+  Be as al,
+  or as am,
+  Sr as an,
+  yr as ao,
+  Er as ap,
+  Ee as aq,
+  Ye as ar,
+  $r as as,
+  ht as at,
+  vn as au,
+  xr as av,
+  Oe as aw,
+  Or as ax,
+  ts as ay,
+  z as az,
+  as as b,
+  us as c,
+  ve as d,
+  x as e,
+  Dr as f,
+  fs as g,
+  Se as h,
+  V as i,
+  D as j,
+  jr as k,
+  p as l,
+  mt as m,
+  gt as n,
+  At as o,
+  ut as p,
+  O as q,
+  vr as r,
+  y as s,
+  G as t,
+  S as u,
+  N as v,
+  pe as w,
+  bt as x,
+  I as y,
+  P as z
+};
+//# sourceMappingURL=_commonjsHelpers-DZ_3pocK.js.map