@konnectio/core 4.0.67 → 4.0.68

package/dist/sentry-D-KvzqAy.js

@@ -0,0 +1,1452 @@
+import "./_sentry-release-injection-file-Bgn3HK9h.js";
+(function() {
+  try {
+    var e = typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, t = new Error().stack;
+    t && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[t] = "1c63d8f7-5f71-4edd-8ae0-62d79a727e77", e._sentryDebugIdIdentifier = "sentry-dbid-1c63d8f7-5f71-4edd-8ae0-62d79a727e77");
+  } catch {
+  }
+})();
+{
+  var P = typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+  P._sentryModuleMetadata = P._sentryModuleMetadata || {}, P._sentryModuleMetadata[new Error().stack] = Object.assign(
+    {},
+    P._sentryModuleMetadata[new Error().stack],
+    { "_sentryBundlerPluginAppKey:konnectio-frontend-core": !0 }
+  );
+}
+const $t = Object.prototype.toString;
+function pt(e, t) {
+  return $t.call(e) === `[object ${t}]`;
+}
+function Dt(e) {
+  return pt(e, "String");
+}
+function _t(e) {
+  return pt(e, "Object");
+}
+function vt(e) {
+  return !!(e && e.then && typeof e.then == "function");
+}
+const C = "8.19.0", S = globalThis;
+function ft(e, t, n) {
+  const s = n || S, r = s.__SENTRY__ = s.__SENTRY__ || {}, i = r[C] = r[C] || {};
+  return i[e] || (i[e] = t());
+}
+const ht = typeof __SENTRY_DEBUG__ > "u" || __SENTRY_DEBUG__, kt = "Sentry Logger ", V = [
+  "debug",
+  "info",
+  "warn",
+  "error",
+  "log",
+  "assert",
+  "trace"
+], W = {};
+function lt(e) {
+  if (!("console" in S))
+    return e();
+  const t = S.console, n = {}, s = Object.keys(W);
+  s.forEach((r) => {
+    const i = W[r];
+    n[r] = t[r], t[r] = i;
+  });
+  try {
+    return e();
+  } finally {
+    s.forEach((r) => {
+      t[r] = n[r];
+    });
+  }
+}
+function Pt() {
+  let e = !1;
+  const t = {
+    enable: () => {
+      e = !0;
+    },
+    disable: () => {
+      e = !1;
+    },
+    isEnabled: () => e
+  };
+  return ht ? V.forEach((n) => {
+    t[n] = (...s) => {
+      e && lt(() => {
+        S.console[n](`${kt}[${n}]:`, ...s);
+      });
+    };
+  }) : V.forEach((n) => {
+    t[n] = () => {
+    };
+  }), t;
+}
+const _ = Pt();
+function Mt(e, t = !1) {
+  const { host: n, path: s, pass: r, port: i, projectId: o, protocol: a, publicKey: u } = e;
+  return `${a}://${u}${t && r ? `:${r}` : ""}@${n}${i ? `:${i}` : ""}/${s && `${s}/`}${o}`;
+}
+function T(e, t, n) {
+  try {
+    Object.defineProperty(e, t, {
+      // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it
+      value: n,
+      writable: !0,
+      configurable: !0
+    });
+  } catch {
+    ht && _.log(`Failed to add non-enumerable property "${t}" to object`, e);
+  }
+}
+function b(e) {
+  return x(e, /* @__PURE__ */ new Map());
+}
+function x(e, t) {
+  if (Lt(e)) {
+    const n = t.get(e);
+    if (n !== void 0)
+      return n;
+    const s = {};
+    t.set(e, s);
+    for (const r of Object.keys(e))
+      typeof e[r] < "u" && (s[r] = x(e[r], t));
+    return s;
+  }
+  if (Array.isArray(e)) {
+    const n = t.get(e);
+    if (n !== void 0)
+      return n;
+    const s = [];
+    return t.set(e, s), e.forEach((r) => {
+      s.push(x(r, t));
+    }), s;
+  }
+  return e;
+}
+function Lt(e) {
+  if (!_t(e))
+    return !1;
+  try {
+    const t = Object.getPrototypeOf(e).constructor.name;
+    return !t || t === "Object";
+  } catch {
+    return !0;
+  }
+}
+const St = 1e3;
+function gt() {
+  return Date.now() / St;
+}
+function xt() {
+  const { performance: e } = S;
+  if (!e || !e.now)
+    return gt;
+  const t = Date.now() - e.now(), n = e.timeOrigin == null ? t : e.timeOrigin;
+  return () => (n + e.now()) / St;
+}
+const $ = xt();
+(() => {
+  const { performance: e } = S;
+  if (!e || !e.now)
+    return;
+  const t = 3600 * 1e3, n = e.now(), s = Date.now(), r = e.timeOrigin ? Math.abs(e.timeOrigin + n - s) : t, i = r < t, o = e.timing && e.timing.navigationStart, u = typeof o == "number" ? Math.abs(o + n - s) : t, c = u < t;
+  return i || c ? r <= u ? e.timeOrigin : o : s;
+})();
+function h() {
+  const e = S, t = e.crypto || e.msCrypto;
+  let n = () => Math.random() * 16;
+  try {
+    if (t && t.randomUUID)
+      return t.randomUUID().replace(/-/g, "");
+    t && t.getRandomValues && (n = () => {
+      const s = new Uint8Array(1);
+      return t.getRandomValues(s), s[0];
+    });
+  } catch {
+  }
+  return ("10000000100040008000" + 1e11).replace(
+    /[018]/g,
+    (s) => (
+      // eslint-disable-next-line no-bitwise
+      (s ^ (n() & 15) >> s / 4).toString(16)
+    )
+  );
+}
+const Ut = "sentry-", Bt = /^sentry-/;
+function Ft(e) {
+  const t = Yt(e);
+  if (!t)
+    return;
+  const n = Object.entries(t).reduce((s, [r, i]) => {
+    if (r.match(Bt)) {
+      const o = r.slice(Ut.length);
+      s[o] = i;
+    }
+    return s;
+  }, {});
+  if (Object.keys(n).length > 0)
+    return n;
+}
+function Yt(e) {
+  if (!(!e || !Dt(e) && !Array.isArray(e)))
+    return Array.isArray(e) ? e.reduce((t, n) => {
+      const s = Z(n);
+      return Object.entries(s).forEach(([r, i]) => {
+        t[r] = i;
+      }), t;
+    }, {}) : Z(e);
+}
+function Z(e) {
+  return e.split(",").map((t) => t.split("=").map((n) => decodeURIComponent(n.trim()))).reduce((t, [n, s]) => (n && s && (t[n] = s), t), {});
+}
+function jt(e, t = []) {
+  return [e, t];
+}
+function Gt(e) {
+  return [{
+    type: "span"
+  }, e];
+}
+function z() {
+  return {
+    traceId: h(),
+    spanId: h().substring(16)
+  };
+}
+const f = typeof __SENTRY_DEBUG__ > "u" || __SENTRY_DEBUG__;
+function R() {
+  return G(S), S;
+}
+function G(e) {
+  const t = e.__SENTRY__ = e.__SENTRY__ || {};
+  return t.version = t.version || C, t[C] = t[C] || {};
+}
+function Kt(e, t = {}) {
+  if (t.user && (!e.ipAddress && t.user.ip_address && (e.ipAddress = t.user.ip_address), !e.did && !t.did && (e.did = t.user.id || t.user.email || t.user.username)), e.timestamp = t.timestamp || $(), t.abnormal_mechanism && (e.abnormal_mechanism = t.abnormal_mechanism), t.ignoreDuration && (e.ignoreDuration = t.ignoreDuration), t.sid && (e.sid = t.sid.length === 32 ? t.sid : h()), t.init !== void 0 && (e.init = t.init), !e.did && t.did && (e.did = `${t.did}`), typeof t.started == "number" && (e.started = t.started), e.ignoreDuration)
+    e.duration = void 0;
+  else if (typeof t.duration == "number")
+    e.duration = t.duration;
+  else {
+    const n = e.timestamp - e.started;
+    e.duration = n >= 0 ? n : 0;
+  }
+  t.release && (e.release = t.release), t.environment && (e.environment = t.environment), !e.ipAddress && t.ipAddress && (e.ipAddress = t.ipAddress), !e.userAgent && t.userAgent && (e.userAgent = t.userAgent), typeof t.errors == "number" && (e.errors = t.errors), t.status && (e.status = t.status);
+}
+const U = "_sentrySpan";
+function B(e, t) {
+  t ? T(e, U, t) : delete e[U];
+}
+function M(e) {
+  return e[U];
+}
+const qt = 100;
+class K {
+  /** 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 = z();
+  }
+  /**
+   * @inheritDoc
+   */
+  clone() {
+    const t = new K();
+    return t._breadcrumbs = [...this._breadcrumbs], t._tags = { ...this._tags }, t._extra = { ...this._extra }, t._contexts = { ...this._contexts }, t._user = this._user, t._level = this._level, t._session = this._session, t._transactionName = this._transactionName, t._fingerprint = this._fingerprint, t._eventProcessors = [...this._eventProcessors], t._requestSession = this._requestSession, t._attachments = [...this._attachments], t._sdkProcessingMetadata = { ...this._sdkProcessingMetadata }, t._propagationContext = { ...this._propagationContext }, t._client = this._client, t._lastEventId = this._lastEventId, B(t, M(this)), t;
+  }
+  /**
+   * @inheritDoc
+   */
+  setClient(t) {
+    this._client = t;
+  }
+  /**
+   * @inheritDoc
+   */
+  setLastEventId(t) {
+    this._lastEventId = t;
+  }
+  /**
+   * @inheritDoc
+   */
+  getClient() {
+    return this._client;
+  }
+  /**
+   * @inheritDoc
+   */
+  lastEventId() {
+    return this._lastEventId;
+  }
+  /**
+   * @inheritDoc
+   */
+  addScopeListener(t) {
+    this._scopeListeners.push(t);
+  }
+  /**
+   * @inheritDoc
+   */
+  addEventProcessor(t) {
+    return this._eventProcessors.push(t), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setUser(t) {
+    return this._user = t || {
+      email: void 0,
+      id: void 0,
+      ip_address: void 0,
+      username: void 0
+    }, this._session && Kt(this._session, { user: t }), this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  getUser() {
+    return this._user;
+  }
+  /**
+   * @inheritDoc
+   */
+  getRequestSession() {
+    return this._requestSession;
+  }
+  /**
+   * @inheritDoc
+   */
+  setRequestSession(t) {
+    return this._requestSession = t, this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setTags(t) {
+    return this._tags = {
+      ...this._tags,
+      ...t
+    }, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setTag(t, n) {
+    return this._tags = { ...this._tags, [t]: n }, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setExtras(t) {
+    return this._extra = {
+      ...this._extra,
+      ...t
+    }, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setExtra(t, n) {
+    return this._extra = { ...this._extra, [t]: n }, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setFingerprint(t) {
+    return this._fingerprint = t, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setLevel(t) {
+    return this._level = t, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setTransactionName(t) {
+    return this._transactionName = t, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setContext(t, n) {
+    return n === null ? delete this._contexts[t] : this._contexts[t] = n, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setSession(t) {
+    return t ? this._session = t : delete this._session, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  getSession() {
+    return this._session;
+  }
+  /**
+   * @inheritDoc
+   */
+  update(t) {
+    if (!t)
+      return this;
+    const n = typeof t == "function" ? t(this) : t, [s, r] = n instanceof I ? [n.getScopeData(), n.getRequestSession()] : _t(n) ? [t, t.requestSession] : [], { tags: i, extra: o, user: a, contexts: u, level: c, fingerprint: d = [], propagationContext: p } = s || {};
+    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), d.length && (this._fingerprint = d), p && (this._propagationContext = p), r && (this._requestSession = r), 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, B(this, void 0), this._attachments = [], this._propagationContext = z(), this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  addBreadcrumb(t, n) {
+    const s = typeof n == "number" ? n : qt;
+    if (s <= 0)
+      return this;
+    const r = {
+      timestamp: gt(),
+      ...t
+    }, i = this._breadcrumbs;
+    return i.push(r), this._breadcrumbs = i.length > s ? i.slice(-s) : i, this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  getLastBreadcrumb() {
+    return this._breadcrumbs[this._breadcrumbs.length - 1];
+  }
+  /**
+   * @inheritDoc
+   */
+  clearBreadcrumbs() {
+    return this._breadcrumbs = [], this._notifyScopeListeners(), this;
+  }
+  /**
+   * @inheritDoc
+   */
+  addAttachment(t) {
+    return this._attachments.push(t), 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: M(this)
+    };
+  }
+  /**
+   * @inheritDoc
+   */
+  setSDKProcessingMetadata(t) {
+    return this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...t }, this;
+  }
+  /**
+   * @inheritDoc
+   */
+  setPropagationContext(t) {
+    return this._propagationContext = t, this;
+  }
+  /**
+   * @inheritDoc
+   */
+  getPropagationContext() {
+    return this._propagationContext;
+  }
+  /**
+   * @inheritDoc
+   */
+  captureException(t, n) {
+    const s = n && n.event_id ? n.event_id : h();
+    if (!this._client)
+      return _.warn("No client configured on scope - will not capture exception!"), s;
+    const r = new Error("Sentry syntheticException");
+    return this._client.captureException(
+      t,
+      {
+        originalException: t,
+        syntheticException: r,
+        ...n,
+        event_id: s
+      },
+      this
+    ), s;
+  }
+  /**
+   * @inheritDoc
+   */
+  captureMessage(t, n, s) {
+    const r = s && s.event_id ? s.event_id : h();
+    if (!this._client)
+      return _.warn("No client configured on scope - will not capture message!"), r;
+    const i = new Error(t);
+    return this._client.captureMessage(
+      t,
+      n,
+      {
+        originalException: t,
+        syntheticException: i,
+        ...s,
+        event_id: r
+      },
+      this
+    ), r;
+  }
+  /**
+   * @inheritDoc
+   */
+  captureEvent(t, n) {
+    const s = n && n.event_id ? n.event_id : h();
+    return this._client ? (this._client.captureEvent(t, { ...n, event_id: s }, this), s) : (_.warn("No client configured on scope - will not capture event!"), s);
+  }
+  /**
+   * This will be called on every set call.
+   */
+  _notifyScopeListeners() {
+    this._notifyingListeners || (this._notifyingListeners = !0, this._scopeListeners.forEach((t) => {
+      t(this);
+    }), this._notifyingListeners = !1);
+  }
+}
+const I = K;
+function Jt() {
+  return ft("defaultCurrentScope", () => new I());
+}
+function Ht() {
+  return ft("defaultIsolationScope", () => new I());
+}
+class Xt {
+  constructor(t, n) {
+    let s;
+    t ? s = t : s = new I();
+    let r;
+    n ? r = n : r = new I(), this._stack = [{ scope: s }], this._isolationScope = r;
+  }
+  /**
+   * Fork a scope for the stack.
+   */
+  withScope(t) {
+    const n = this._pushScope();
+    let s;
+    try {
+      s = t(n);
+    } catch (r) {
+      throw this._popScope(), r;
+    }
+    return vt(s) ? s.then(
+      (r) => (this._popScope(), r),
+      (r) => {
+        throw this._popScope(), r;
+      }
+    ) : (this._popScope(), s);
+  }
+  /**
+   * 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 t = this.getScope().clone();
+    return this._stack.push({
+      client: this.getClient(),
+      scope: t
+    }), t;
+  }
+  /**
+   * Pop a scope from the stack.
+   */
+  _popScope() {
+    return this._stack.length <= 1 ? !1 : !!this._stack.pop();
+  }
+}
+function A() {
+  const e = R(), t = G(e);
+  return t.stack = t.stack || new Xt(Jt(), Ht());
+}
+function Vt(e) {
+  return A().withScope(e);
+}
+function Wt(e, t) {
+  const n = A();
+  return n.withScope(() => (n.getStackTop().scope = e, t(e)));
+}
+function Q(e) {
+  return A().withScope(() => e(A().getIsolationScope()));
+}
+function Zt() {
+  return {
+    withIsolationScope: Q,
+    withScope: Vt,
+    withSetScope: Wt,
+    withSetIsolationScope: (e, t) => Q(t),
+    getCurrentScope: () => A().getScope(),
+    getIsolationScope: () => A().getIsolationScope()
+  };
+}
+function v(e) {
+  const t = G(e);
+  return t.acs ? t.acs : Zt();
+}
+function N() {
+  const e = R();
+  return v(e).getCurrentScope();
+}
+function zt() {
+  const e = R();
+  return v(e).getIsolationScope();
+}
+function mt(...e) {
+  const t = R(), n = v(t);
+  if (e.length === 2) {
+    const [s, r] = e;
+    return s ? n.withSetScope(s, r) : n.withScope(r);
+  }
+  return n.withScope(e[0]);
+}
+function g() {
+  return N().getClient();
+}
+const Qt = "_sentryMetrics";
+function F(e) {
+  const t = e[Qt];
+  if (!t)
+    return;
+  const n = {};
+  for (const [, [s, r]] of t)
+    (n[s] || (n[s] = [])).push(b(r));
+  return n;
+}
+const q = "sentry.source", yt = "sentry.sample_rate", Y = "sentry.op", D = "sentry.origin", te = "sentry.measurement_unit", ee = "sentry.measurement_value", ne = "sentry.profile_id", se = "sentry.exclusive_time", re = 0, ie = 1, Et = 0, Tt = 1;
+function oe(e) {
+  const { spanId: t, traceId: n } = e.spanContext(), { data: s, op: r, parent_span_id: i, status: o, origin: a } = l(e);
+  return b({
+    parent_span_id: i,
+    span_id: t,
+    trace_id: n,
+    data: s,
+    op: r,
+    status: o,
+    origin: a
+  });
+}
+function E(e) {
+  return typeof e == "number" ? tt(e) : Array.isArray(e) ? e[0] + e[1] / 1e9 : e instanceof Date ? tt(e.getTime()) : $();
+}
+function tt(e) {
+  return e > 9999999999 ? e / 1e3 : e;
+}
+function l(e) {
+  if (ce(e))
+    return e.getSpanJSON();
+  try {
+    const { spanId: t, traceId: n } = e.spanContext();
+    if (ae(e)) {
+      const { attributes: s, startTime: r, name: i, endTime: o, parentSpanId: a, status: u } = e;
+      return b({
+        span_id: t,
+        trace_id: n,
+        data: s,
+        description: i,
+        parent_span_id: a,
+        start_timestamp: E(r),
+        // This is [0,0] by default in OTEL, in which case we want to interpret this as no end time
+        timestamp: E(o) || void 0,
+        status: bt(u),
+        op: s[Y],
+        origin: s[D],
+        _metrics_summary: F(e)
+      });
+    }
+    return {
+      span_id: t,
+      trace_id: n
+    };
+  } catch {
+    return {};
+  }
+}
+function ae(e) {
+  const t = e;
+  return !!t.attributes && !!t.startTime && !!t.name && !!t.endTime && !!t.status;
+}
+function ce(e) {
+  return typeof e.getSpanJSON == "function";
+}
+function k(e) {
+  const { traceFlags: t } = e.spanContext();
+  return t === Tt;
+}
+function bt(e) {
+  if (!(!e || e.code === re))
+    return e.code === ie ? "ok" : e.message || "unknown_error";
+}
+const O = "_sentryChildSpans", j = "_sentryRootSpan";
+function It(e, t) {
+  const n = e[j] || e;
+  T(t, j, n), e[O] ? e[O].add(t) : T(e, O, /* @__PURE__ */ new Set([t]));
+}
+function ue(e) {
+  const t = /* @__PURE__ */ new Set();
+  function n(s) {
+    if (!t.has(s) && k(s)) {
+      t.add(s);
+      const r = s[O] ? Array.from(s[O]) : [];
+      for (const i of r)
+        n(i);
+    }
+  }
+  return n(e), Array.from(t);
+}
+function y(e) {
+  return e[j] || e;
+}
+function et() {
+  const e = R(), t = v(e);
+  return t.getActiveSpan ? t.getActiveSpan() : M(N());
+}
+const At = "_sentryScope", Nt = "_sentryIsolationScope";
+function de(e, t, n) {
+  e && (T(e, Nt, n), T(e, At, t));
+}
+function nt(e) {
+  return {
+    scope: e[At],
+    isolationScope: e[Nt]
+  };
+}
+function Rt(e) {
+  if (typeof __SENTRY_TRACING__ == "boolean" && !__SENTRY_TRACING__)
+    return !1;
+  const t = e || pe();
+  return !!t && (t.enableTracing || "tracesSampleRate" in t || "tracesSampler" in t);
+}
+function pe() {
+  const e = g();
+  return e && e.getOptions();
+}
+class J {
+  constructor(t = {}) {
+    this._traceId = t.traceId || h(), this._spanId = t.spanId || h().substring(16);
+  }
+  /** @inheritdoc */
+  spanContext() {
+    return {
+      spanId: this._spanId,
+      traceId: this._traceId,
+      traceFlags: Et
+    };
+  }
+  /** @inheritdoc */
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  end(t) {
+  }
+  /** @inheritdoc */
+  setAttribute(t, n) {
+    return this;
+  }
+  /** @inheritdoc */
+  setAttributes(t) {
+    return this;
+  }
+  /** @inheritdoc */
+  setStatus(t) {
+    return this;
+  }
+  /** @inheritdoc */
+  updateName(t) {
+    return this;
+  }
+  /** @inheritdoc */
+  isRecording() {
+    return !1;
+  }
+  /** @inheritdoc */
+  addEvent(t, n, s) {
+    return this;
+  }
+  /**
+   * This should generally not be used,
+   * but we need it for being comliant with the OTEL Span interface.
+   *
+   * @hidden
+   * @internal
+   */
+  addLink(t) {
+    return this;
+  }
+  /**
+   * This should generally not be used,
+   * but we need it for being comliant with the OTEL Span interface.
+   *
+   * @hidden
+   * @internal
+   */
+  addLinks(t) {
+    return this;
+  }
+  /**
+   * This should generally not be used,
+   * but we need it for being comliant with the OTEL Span interface.
+   *
+   * @hidden
+   * @internal
+   */
+  recordException(t, n) {
+  }
+}
+const _e = "production", Ct = "_frozenDsc";
+function st(e, t) {
+  T(e, Ct, t);
+}
+function fe(e, t) {
+  const n = t.getOptions(), { publicKey: s } = t.getDsn() || {}, r = b({
+    environment: n.environment || _e,
+    release: n.release,
+    public_key: s,
+    trace_id: e
+  });
+  return t.emit("createDsc", r), r;
+}
+function H(e) {
+  const t = g();
+  if (!t)
+    return {};
+  const n = fe(l(e).trace_id || "", t), s = y(e), r = s[Ct];
+  if (r)
+    return r;
+  const i = s.spanContext().traceState, o = i && i.get("sentry.dsc"), a = o && Ft(o);
+  if (a)
+    return a;
+  const u = l(s), c = u.data || {}, d = c[yt];
+  d != null && (n.sample_rate = `${d}`);
+  const p = c[q], m = u.description;
+  return p !== "url" && m && (n.transaction = m), n.sampled = String(k(s)), t.emit("createDsc", n, s), n;
+}
+function he(e) {
+  if (!f) return;
+  const { description: t = "< unknown name >", op: n = "< unknown op >", parent_span_id: s } = l(e), { spanId: r } = e.spanContext(), i = k(e), o = y(e), a = o === e, u = `[Tracing] Starting ${i ? "sampled" : "unsampled"} ${a ? "root " : ""}span`, c = [`op: ${n}`, `name: ${t}`, `ID: ${r}`];
+  if (s && c.push(`parent ID: ${s}`), !a) {
+    const { op: d, description: p } = l(o);
+    c.push(`root ID: ${o.spanContext().spanId}`), d && c.push(`root op: ${d}`), p && c.push(`root description: ${p}`);
+  }
+  _.log(`${u}
+  ${c.join(`
+  `)}`);
+}
+function le(e) {
+  if (!f) return;
+  const { description: t = "< unknown name >", op: n = "< unknown op >" } = l(e), { spanId: s } = e.spanContext(), i = y(e) === e, o = `[Tracing] Finishing "${n}" ${i ? "root " : ""}span "${t}" with ID ${s}`;
+  _.log(o);
+}
+function Se(e) {
+  if (typeof e == "boolean")
+    return Number(e);
+  const t = typeof e == "string" ? parseFloat(e) : e;
+  if (typeof t != "number" || isNaN(t) || t < 0 || t > 1) {
+    f && _.warn(
+      `[Tracing] Given sample rate is invalid. Sample rate must be a boolean or a number between 0 and 1. Got ${JSON.stringify(
+        e
+      )} of type ${JSON.stringify(typeof e)}.`
+    );
+    return;
+  }
+  return t;
+}
+function ge(e, t) {
+  if (!Rt(e))
+    return [!1];
+  let n;
+  typeof e.tracesSampler == "function" ? n = e.tracesSampler(t) : t.parentSampled !== void 0 ? n = t.parentSampled : typeof e.tracesSampleRate < "u" ? n = e.tracesSampleRate : n = 1;
+  const s = Se(n);
+  return s === void 0 ? (f && _.warn("[Tracing] Discarding transaction because of invalid sample rate."), [!1]) : s ? Math.random() < s ? [!0, s] : (f && _.log(
+    `[Tracing] Discarding transaction because it's not included in the random sample (sampling rate = ${Number(
+      n
+    )})`
+  ), [!1, s]) : (f && _.log(
+    `[Tracing] Discarding transaction because ${typeof e.tracesSampler == "function" ? "tracesSampler returned 0 or false" : "a negative sampling decision was inherited or tracesSampleRate is set to 0"}`
+  ), [!1, s]);
+}
+function me(e, t) {
+  function n(d) {
+    return !!d.trace_id && !!d.public_key;
+  }
+  const s = H(e[0]), r = t && t.getDsn(), i = t && t.getOptions().tunnel, o = {
+    sent_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...n(s) && { trace: s },
+    ...!!i && r && { dsn: Mt(r) }
+  }, a = t && t.getOptions().beforeSendSpan, u = a ? (d) => a(l(d)) : (d) => l(d), c = [];
+  for (const d of e) {
+    const p = u(d);
+    p && c.push(Gt(p));
+  }
+  return jt(o, c);
+}
+function rt(e) {
+  if (!e || e.length === 0)
+    return;
+  const t = {};
+  return e.forEach((n) => {
+    const s = n.attributes || {}, r = s[te], i = s[ee];
+    typeof r == "string" && typeof i == "number" && (t[n.name] = { value: i, unit: r });
+  }), t;
+}
+const it = 1e3;
+class X {
+  /** 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(t = {}) {
+    this._traceId = t.traceId || h(), this._spanId = t.spanId || h().substring(16), this._startTime = t.startTimestamp || $(), this._attributes = {}, this.setAttributes({
+      [D]: "manual",
+      [Y]: t.op,
+      ...t.attributes
+    }), this._name = t.name, t.parentSpanId && (this._parentSpanId = t.parentSpanId), "sampled" in t && (this._sampled = t.sampled), t.endTimestamp && (this._endTime = t.endTimestamp), this._events = [], this._isStandaloneSpan = t.isStandalone, this._endTime && this._onSpanEnded();
+  }
+  /**
+   * This should generally not be used,
+   * but it is needed for being compliant with the OTEL Span interface.
+   *
+   * @hidden
+   * @internal
+   */
+  addLink(t) {
+    return this;
+  }
+  /**
+   * This should generally not be used,
+   * but it is needed for being compliant with the OTEL Span interface.
+   *
+   * @hidden
+   * @internal
+   */
+  addLinks(t) {
+    return this;
+  }
+  /**
+   * This should generally not be used,
+   * but it is needed for being compliant with the OTEL Span interface.
+   *
+   * @hidden
+   * @internal
+   */
+  recordException(t, n) {
+  }
+  /** @inheritdoc */
+  spanContext() {
+    const { _spanId: t, _traceId: n, _sampled: s } = this;
+    return {
+      spanId: t,
+      traceId: n,
+      traceFlags: s ? Tt : Et
+    };
+  }
+  /** @inheritdoc */
+  setAttribute(t, n) {
+    return n === void 0 ? delete this._attributes[t] : this._attributes[t] = n, this;
+  }
+  /** @inheritdoc */
+  setAttributes(t) {
+    return Object.keys(t).forEach((n) => this.setAttribute(n, t[n])), this;
+  }
+  /**
+   * 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(t) {
+    this._startTime = E(t);
+  }
+  /**
+   * @inheritDoc
+   */
+  setStatus(t) {
+    return this._status = t, this;
+  }
+  /**
+   * @inheritDoc
+   */
+  updateName(t) {
+    return this._name = t, this;
+  }
+  /** @inheritdoc */
+  end(t) {
+    this._endTime || (this._endTime = E(t), le(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 b({
+      data: this._attributes,
+      description: this._name,
+      op: this._attributes[Y],
+      parent_span_id: this._parentSpanId,
+      span_id: this._spanId,
+      start_timestamp: this._startTime,
+      status: bt(this._status),
+      timestamp: this._endTime,
+      trace_id: this._traceId,
+      origin: this._attributes[D],
+      _metrics_summary: F(this),
+      profile_id: this._attributes[ne],
+      exclusive_time: this._attributes[se],
+      measurements: rt(this._events),
+      is_segment: this._isStandaloneSpan && y(this) === this || void 0,
+      segment_id: this._isStandaloneSpan ? y(this).spanContext().spanId : void 0
+    });
+  }
+  /** @inheritdoc */
+  isRecording() {
+    return !this._endTime && !!this._sampled;
+  }
+  /**
+   * @inheritdoc
+   */
+  addEvent(t, n, s) {
+    f && _.log("[Tracing] Adding an event to span:", t);
+    const r = ot(n) ? n : s || $(), i = ot(n) ? {} : n || {}, o = {
+      name: t,
+      time: E(r),
+      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 t = g();
+    if (t && t.emit("spanEnd", this), !(this._isStandaloneSpan || this === y(this)))
+      return;
+    if (this._isStandaloneSpan) {
+      this._sampled ? Ee(me([this], t)) : (f && _.log("[Tracing] Discarding standalone span because its trace was not chosen to be sampled."), t && t.recordDroppedEvent("sample_rate", "span"));
+      return;
+    }
+    const s = this._convertSpanToTransaction();
+    s && (nt(this).scope || N()).captureEvent(s);
+  }
+  /**
+   * Finish the transaction & prepare the event to send to Sentry.
+   */
+  _convertSpanToTransaction() {
+    if (!at(l(this)))
+      return;
+    this._name || (f && _.warn("Transaction has no name, falling back to `<unlabeled transaction>`."), this._name = "<unlabeled transaction>");
+    const { scope: t, isolationScope: n } = nt(this), r = (t || N()).getClient() || g();
+    if (this._sampled !== !0) {
+      f && _.log("[Tracing] Discarding transaction because its trace was not chosen to be sampled."), r && r.recordDroppedEvent("sample_rate", "transaction");
+      return;
+    }
+    const o = ue(this).filter((p) => p !== this && !ye(p)).map((p) => l(p)).filter(at), a = this._attributes[q], u = {
+      contexts: {
+        trace: oe(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 > it ? o.sort((p, m) => p.start_timestamp - m.start_timestamp).slice(0, it) : o
+      ),
+      start_timestamp: this._startTime,
+      timestamp: this._endTime,
+      transaction: this._name,
+      type: "transaction",
+      sdkProcessingMetadata: {
+        capturedSpanScope: t,
+        capturedSpanIsolationScope: n,
+        ...b({
+          dynamicSamplingContext: H(this)
+        })
+      },
+      _metrics_summary: F(this),
+      ...a && {
+        transaction_info: {
+          source: a
+        }
+      }
+    }, c = rt(this._events);
+    return c && Object.keys(c).length && (f && _.log(
+      "[Measurements] Adding measurements to transaction event",
+      JSON.stringify(c, void 0, 2)
+    ), u.measurements = c), u;
+  }
+}
+function ot(e) {
+  return e && typeof e == "number" || e instanceof Date || Array.isArray(e);
+}
+function at(e) {
+  return !!e.start_timestamp && !!e.timestamp && !!e.span_id && !!e.trace_id;
+}
+function ye(e) {
+  return e instanceof X && e.isStandaloneSpan();
+}
+function Ee(e) {
+  const t = g();
+  if (!t)
+    return;
+  const n = e[1];
+  if (!n || n.length === 0) {
+    t.recordDroppedEvent("before_send", "span");
+    return;
+  }
+  const s = t.getTransport();
+  s && s.send(e).then(null, (r) => {
+    f && _.error("Error while sending span:", r);
+  });
+}
+const Ot = "__SENTRY_SUPPRESS_TRACING__";
+function ct(e) {
+  const t = wt();
+  if (t.startInactiveSpan)
+    return t.startInactiveSpan(e);
+  const n = Ie(e), { forceTransaction: s, parentSpan: r } = e;
+  return (e.scope ? (o) => mt(e.scope, o) : r !== void 0 ? (o) => Te(r, o) : (o) => o())(() => {
+    const o = N(), a = Ne(o);
+    return e.onlyIfParent && !a ? new J() : be({
+      parentSpan: a,
+      spanArguments: n,
+      forceTransaction: s,
+      scope: o
+    });
+  });
+}
+function Te(e, t) {
+  const n = wt();
+  return n.withActiveSpan ? n.withActiveSpan(e, t) : mt((s) => (B(s, e || void 0), t(s)));
+}
+function be({
+  parentSpan: e,
+  spanArguments: t,
+  forceTransaction: n,
+  scope: s
+}) {
+  if (!Rt())
+    return new J();
+  const r = zt();
+  let i;
+  if (e && !n)
+    i = Ae(e, s, t), It(e, i);
+  else if (e) {
+    const o = H(e), { traceId: a, spanId: u } = e.spanContext(), c = k(e);
+    i = ut(
+      {
+        traceId: a,
+        parentSpanId: u,
+        ...t
+      },
+      s,
+      c
+    ), st(i, o);
+  } else {
+    const {
+      traceId: o,
+      dsc: a,
+      parentSpanId: u,
+      sampled: c
+    } = {
+      ...r.getPropagationContext(),
+      ...s.getPropagationContext()
+    };
+    i = ut(
+      {
+        traceId: o,
+        parentSpanId: u,
+        ...t
+      },
+      s,
+      c
+    ), a && st(i, a);
+  }
+  return he(i), de(i, s, r), i;
+}
+function Ie(e) {
+  const n = {
+    isStandalone: (e.experimental || {}).standalone,
+    ...e
+  };
+  if (e.startTime) {
+    const s = { ...n };
+    return s.startTimestamp = E(e.startTime), delete s.startTime, s;
+  }
+  return n;
+}
+function wt() {
+  const e = R();
+  return v(e);
+}
+function ut(e, t, n) {
+  const s = g(), r = s && s.getOptions() || {}, { name: i = "", attributes: o } = e, [a, u] = t.getScopeData().sdkProcessingMetadata[Ot] ? [!1] : ge(r, {
+    name: i,
+    parentSampled: n,
+    attributes: o,
+    transactionContext: {
+      name: i,
+      parentSampled: n
+    }
+  }), c = new X({
+    ...e,
+    attributes: {
+      [q]: "custom",
+      ...e.attributes
+    },
+    sampled: a
+  });
+  return u !== void 0 && c.setAttribute(yt, u), s && s.emit("spanStart", c), c;
+}
+function Ae(e, t, n) {
+  const { spanId: s, traceId: r } = e.spanContext(), i = t.getScopeData().sdkProcessingMetadata[Ot] ? !1 : k(e), o = i ? new X({
+    ...n,
+    parentSpanId: s,
+    traceId: r,
+    sampled: i
+  }) : new J({ traceId: r });
+  It(e, o);
+  const a = g();
+  return a && (a.emit("spanStart", o), n.endTimestamp && a.emit("spanEnd", o)), o;
+}
+function Ne(e) {
+  const t = M(e);
+  if (!t)
+    return;
+  const n = g();
+  return (n ? n.getOptions() : {}).parentSpanIsAlwaysRootSpan ? y(t) : t;
+}
+function Re(e) {
+  if (e)
+    return Ce(e) ? { captureContext: e } : we(e) ? {
+      captureContext: e
+    } : e;
+}
+function Ce(e) {
+  return e instanceof I || typeof e == "function";
+}
+const Oe = [
+  "user",
+  "level",
+  "extra",
+  "contexts",
+  "tags",
+  "fingerprint",
+  "requestSession",
+  "propagationContext"
+];
+function we(e) {
+  return Object.keys(e).some((t) => Oe.includes(t));
+}
+function $e(e, t) {
+  return N().captureException(e, Re(t));
+}
+const De = ["activate", "mount", "update"], ve = typeof __SENTRY_DEBUG__ > "u" || __SENTRY_DEBUG__, ke = /(?:^|[-_])(\w)/g, Pe = (e) => e.replace(ke, (t) => t.toUpperCase()).replace(/[-_]/g, ""), Me = "<Root>", L = "<Anonymous>", Le = (e, t) => e.repeat(t), w = (e, t) => {
+  if (!e)
+    return L;
+  if (e.$root === e)
+    return Me;
+  if (!e.$options)
+    return L;
+  const n = e.$options;
+  let s = n.name || n._componentTag;
+  const r = n.__file;
+  if (!s && r) {
+    const i = r.match(/([^/\\]+)\.vue$/);
+    i && (s = i[1]);
+  }
+  return (s ? `<${Pe(s)}>` : L) + (r && t !== !1 ? ` at ${r}` : "");
+}, xe = (e) => {
+  if (e && (e._isVue || e.__isVue) && e.$parent) {
+    const t = [];
+    let n = 0;
+    for (; e; ) {
+      if (t.length > 0) {
+        const r = t[t.length - 1];
+        if (r.constructor === e.constructor) {
+          n++, e = e.$parent;
+          continue;
+        } else n > 0 && (t[t.length - 1] = [r, n], n = 0);
+      }
+      t.push(e), e = e.$parent;
+    }
+    return `
+
+found in
+
+${t.map(
+      (r, i) => `${(i === 0 ? "---> " : Le(" ", 5 + i * 2)) + (Array.isArray(r) ? `${w(r[0])}... (${r[1]} recursive calls)` : w(r))}`
+    ).join(`
+`)}`;
+  }
+  return `
+
+(found in ${w(e)})`;
+}, Ue = (e, t) => {
+  const { errorHandler: n, warnHandler: s, silent: r } = e.config;
+  e.config.errorHandler = (i, o, a) => {
+    const u = w(o, !1), c = o ? xe(o) : "", d = {
+      componentName: u,
+      lifecycleHook: a,
+      trace: c
+    };
+    if (t.attachProps && o && (o.$options && o.$options.propsData ? d.propsData = o.$options.propsData : o.$props && (d.propsData = o.$props)), setTimeout(() => {
+      $e(i, {
+        captureContext: { contexts: { vue: d } },
+        mechanism: { handled: !1 }
+      });
+    }), typeof n == "function" && n.call(e, i, o, a), t.logErrors) {
+      const p = typeof console < "u", m = `Error in ${a}: "${i && i.toString()}"`;
+      s ? s.call(null, m, o, c) : p && !r && lt(() => {
+        console.error(`[Vue warn]: ${m}${c}`);
+      });
+    }
+  };
+}, dt = "ui.vue", Be = {
+  activate: ["activated", "deactivated"],
+  create: ["beforeCreate", "created"],
+  // Vue 3
+  unmount: ["beforeUnmount", "unmounted"],
+  // Vue 2
+  destroy: ["beforeDestroy", "destroyed"],
+  mount: ["beforeMount", "mounted"],
+  update: ["beforeUpdate", "updated"]
+};
+function Fe(e, t, n) {
+  e.$_sentryRootSpanTimer && clearTimeout(e.$_sentryRootSpanTimer), e.$_sentryRootSpanTimer = setTimeout(() => {
+    e.$root && e.$root.$_sentryRootSpan && (e.$root.$_sentryRootSpan.end(t), e.$root.$_sentryRootSpan = void 0);
+  }, n);
+}
+const Ye = (e) => {
+  const t = (e.hooks || []).concat(De).filter((s, r, i) => i.indexOf(s) === r), n = {};
+  for (const s of t) {
+    const r = Be[s];
+    if (!r) {
+      ve && _.warn(`Unknown hook: ${s}`);
+      continue;
+    }
+    for (const i of r)
+      n[i] = function() {
+        const o = this.$root === this;
+        o && et() && (this.$_sentryRootSpan = this.$_sentryRootSpan || ct({
+          name: "Application Render",
+          op: `${dt}.render`,
+          attributes: {
+            [D]: "auto.ui.vue"
+          }
+        }));
+        const a = w(this, !1), u = Array.isArray(e.trackComponents) ? e.trackComponents.indexOf(a) > -1 : e.trackComponents;
+        if (!(!o && !u))
+          if (this.$_sentrySpans = this.$_sentrySpans || {}, i == r[0]) {
+            if (this.$root && this.$root.$_sentryRootSpan || et()) {
+              const d = this.$_sentrySpans[s];
+              d && d.end(), this.$_sentrySpans[s] = ct({
+                name: `Vue <${a}>`,
+                op: `${dt}.${s}`,
+                attributes: {
+                  [D]: "auto.ui.vue"
+                }
+              });
+            }
+          } else {
+            const c = this.$_sentrySpans[s];
+            if (!c) return;
+            c.end(), Fe(this, $(), e.timeout);
+          }
+      };
+  }
+  return n;
+};
+function Ge(e) {
+  e.mixin(Ye({
+    trackComponents: !1
+  })), Ue(e);
+}
+export {
+  Ge as c
+};
+//# sourceMappingURL=sentry-D-KvzqAy.js.map