{"version":3,"file":"js/962-0d2b0bb85b9dec6a8024.js","mappings":"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","sources":["webpack:///./node_modules/@sentry/core/esm/exports.js","webpack:///./node_modules/@sentry/core/esm/hub.js","webpack:///./node_modules/@sentry/core/esm/scope.js","webpack:///./node_modules/@sentry/core/esm/session.js","webpack:///./node_modules/@sentry/utils/esm/browser.js","webpack:///./node_modules/@sentry/utils/esm/env.js","webpack:///./node_modules/@sentry/utils/esm/is.js","webpack:///./node_modules/@sentry/utils/esm/logger.js","webpack:///./node_modules/@sentry/utils/esm/misc.js","webpack:///./node_modules/@sentry/utils/esm/node.js","webpack:///./node_modules/@sentry/utils/esm/object.js","webpack:///./node_modules/@sentry/utils/esm/string.js","webpack:///./node_modules/@sentry/utils/esm/syncpromise.js","webpack:///./node_modules/@sentry/utils/esm/time.js","webpack:///./node_modules/@sentry/utils/esm/worldwide.js","webpack:///./node_modules/@sentry/webpack-plugin/src/sentry-webpack.module.js"],"sourcesContent":["import { getCurrentHub } from './hub.js';\n\n// Note: All functions in this file are typed with a return value of `ReturnType<Hub[HUB_FUNCTION]>`,\n// where HUB_FUNCTION is some method on the Hub class.\n//\n// This is done to make sure the top level SDK methods stay in sync with the hub methods.\n// Although every method here has an explicit return type, some of them (that map to void returns) do not\n// contain `return` keywords. This is done to save on bundle size, as `return` is not minifiable.\n\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception An exception-like object.\n * @param captureContext Additional scope data to apply to exception event.\n * @returns The generated eventId.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nfunction captureException(exception, captureContext) {\n  return getCurrentHub().captureException(exception, { captureContext });\n}\n\n/**\n * Captures a message event and sends it to Sentry.\n *\n * @param message The message to send to Sentry.\n * @param Severity Define the level of the message.\n * @returns The generated eventId.\n */\nfunction captureMessage(\n  message,\n  // eslint-disable-next-line deprecation/deprecation\n  captureContext,\n) {\n  // This is necessary to provide explicit scopes upgrade, without changing the original\n  // arity of the `captureMessage(message, level)` method.\n  const level = typeof captureContext === 'string' ? captureContext : undefined;\n  const context = typeof captureContext !== 'string' ? { captureContext } : undefined;\n  return getCurrentHub().captureMessage(message, level, context);\n}\n\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @returns The generated eventId.\n */\nfunction captureEvent(event, hint) {\n  return getCurrentHub().captureEvent(event, hint);\n}\n\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n */\nfunction configureScope(callback) {\n  getCurrentHub().configureScope(callback);\n}\n\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on\n * user's actions prior to an error or crash.\n *\n * @param breadcrumb The breadcrumb to record.\n */\nfunction addBreadcrumb(breadcrumb) {\n  getCurrentHub().addBreadcrumb(breadcrumb);\n}\n\n/**\n * Sets context data with the given name.\n * @param name of the context\n * @param context Any kind of data. This data will be normalized.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction setContext(name, context) {\n  getCurrentHub().setContext(name, context);\n}\n\n/**\n * Set an object that will be merged sent as extra data with the event.\n * @param extras Extras object to merge into current context.\n */\nfunction setExtras(extras) {\n  getCurrentHub().setExtras(extras);\n}\n\n/**\n * Set key:value that will be sent as extra data with the event.\n * @param key String of extra\n * @param extra Any kind of data. This data will be normalized.\n */\nfunction setExtra(key, extra) {\n  getCurrentHub().setExtra(key, extra);\n}\n\n/**\n * Set an object that will be merged sent as tags data with the event.\n * @param tags Tags context object to merge into current context.\n */\nfunction setTags(tags) {\n  getCurrentHub().setTags(tags);\n}\n\n/**\n * Set key:value that will be sent as tags data with the event.\n *\n * Can also be used to unset a tag, by passing `undefined`.\n *\n * @param key String key of tag\n * @param value Value of tag\n */\nfunction setTag(key, value) {\n  getCurrentHub().setTag(key, value);\n}\n\n/**\n * Updates user context information for future events.\n *\n * @param user User context object to be set in the current context. Pass `null` to unset the user.\n */\nfunction setUser(user) {\n  getCurrentHub().setUser(user);\n}\n\n/**\n * Creates a new scope with and executes the given operation within.\n * The scope is automatically removed once the operation\n * finishes or throws.\n *\n * This is essentially a convenience function for:\n *\n *     pushScope();\n *     callback();\n *     popScope();\n *\n * @param callback that will be enclosed into push/popScope.\n */\nfunction withScope(callback) {\n  getCurrentHub().withScope(callback);\n}\n\n/**\n * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.\n *\n * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a\n * new child span within the transaction or any span, call the respective `.startChild()` method.\n *\n * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.\n *\n * The transaction must be finished with a call to its `.finish()` method, at which point the transaction with all its\n * finished child spans will be sent to Sentry.\n *\n * NOTE: This function should only be used for *manual* instrumentation. Auto-instrumentation should call\n * `startTransaction` directly on the hub.\n *\n * @param context Properties of the new `Transaction`.\n * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent\n * default values). See {@link Options.tracesSampler}.\n *\n * @returns The transaction which was just started\n */\nfunction startTransaction(\n  context,\n  customSamplingContext,\n) {\n  return getCurrentHub().startTransaction({ ...context }, customSamplingContext);\n}\n\nexport { addBreadcrumb, captureEvent, captureException, captureMessage, configureScope, setContext, setExtra, setExtras, setTag, setTags, setUser, startTransaction, withScope };\n//# sourceMappingURL=exports.js.map\n","import { uuid4, dateTimestampInSeconds, consoleSandbox, logger, GLOBAL_OBJ, isNodeEnv, getGlobalSingleton } from '@sentry/utils';\nimport { Scope } from './scope.js';\nimport { closeSession, makeSession, updateSession } from './session.js';\n\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be increased when the global interface\n * changes and new methods are introduced.\n *\n * @hidden\n */\nconst API_VERSION = 4;\n\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nconst DEFAULT_BREADCRUMBS = 100;\n\n/**\n * A layer in the process stack.\n * @hidden\n */\n\n/**\n * @inheritDoc\n */\nclass Hub  {\n  /** Is a {@link Layer}[] containing the client and scope */\n    __init() {this._stack = [{}];}\n\n  /** Contains the last event id of a captured event.  */\n\n  /**\n   * Creates a new instance of the hub, will push one {@link Layer} into the\n   * internal stack on creation.\n   *\n   * @param client bound to the hub.\n   * @param scope bound to the hub.\n   * @param version number, higher number means higher priority.\n   */\n   constructor(client, scope = new Scope(),   _version = API_VERSION) {this._version = _version;Hub.prototype.__init.call(this);\n    this.getStackTop().scope = scope;\n    if (client) {\n      this.bindClient(client);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   isOlderThan(version) {\n    return this._version < version;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   bindClient(client) {\n    const top = this.getStackTop();\n    top.client = client;\n    if (client && client.setupIntegrations) {\n      client.setupIntegrations();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   pushScope() {\n    // We want to clone the content of prev scope\n    const scope = Scope.clone(this.getScope());\n    this.getStack().push({\n      client: this.getClient(),\n      scope,\n    });\n    return scope;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   popScope() {\n    if (this.getStack().length <= 1) return false;\n    return !!this.getStack().pop();\n  }\n\n  /**\n   * @inheritDoc\n   */\n   withScope(callback) {\n    const scope = this.pushScope();\n    try {\n      callback(scope);\n    } finally {\n      this.popScope();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getClient() {\n    return this.getStackTop().client ;\n  }\n\n  /** Returns the scope of the top stack. */\n   getScope() {\n    return this.getStackTop().scope;\n  }\n\n  /** Returns the scope stack for domains or the process. */\n   getStack() {\n    return this._stack;\n  }\n\n  /** Returns the topmost scope layer in the order domain > local > process. */\n   getStackTop() {\n    return this._stack[this._stack.length - 1];\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n   captureException(exception, hint) {\n    const eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n    const syntheticException = new Error('Sentry syntheticException');\n    this._withClient((client, scope) => {\n      client.captureException(\n        exception,\n        {\n          originalException: exception,\n          syntheticException,\n          ...hint,\n          event_id: eventId,\n        },\n        scope,\n      );\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureMessage(\n    message,\n    // eslint-disable-next-line deprecation/deprecation\n    level,\n    hint,\n  ) {\n    const eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n    const syntheticException = new Error(message);\n    this._withClient((client, scope) => {\n      client.captureMessage(\n        message,\n        level,\n        {\n          originalException: message,\n          syntheticException,\n          ...hint,\n          event_id: eventId,\n        },\n        scope,\n      );\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureEvent(event, hint) {\n    const eventId = hint && hint.event_id ? hint.event_id : uuid4();\n    if (!event.type) {\n      this._lastEventId = eventId;\n    }\n\n    this._withClient((client, scope) => {\n      client.captureEvent(event, { ...hint, event_id: eventId }, scope);\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   lastEventId() {\n    return this._lastEventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   addBreadcrumb(breadcrumb, hint) {\n    const { scope, client } = this.getStackTop();\n\n    if (!scope || !client) return;\n\n    const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } =\n      (client.getOptions && client.getOptions()) || {};\n\n    if (maxBreadcrumbs <= 0) return;\n\n    const timestamp = dateTimestampInSeconds();\n    const mergedBreadcrumb = { timestamp, ...breadcrumb };\n    const finalBreadcrumb = beforeBreadcrumb\n      ? (consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) )\n      : mergedBreadcrumb;\n\n    if (finalBreadcrumb === null) return;\n\n    scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setUser(user) {\n    const scope = this.getScope();\n    if (scope) scope.setUser(user);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTags(tags) {\n    const scope = this.getScope();\n    if (scope) scope.setTags(tags);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setExtras(extras) {\n    const scope = this.getScope();\n    if (scope) scope.setExtras(extras);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTag(key, value) {\n    const scope = this.getScope();\n    if (scope) scope.setTag(key, value);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setExtra(key, extra) {\n    const scope = this.getScope();\n    if (scope) scope.setExtra(key, extra);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n   setContext(name, context) {\n    const scope = this.getScope();\n    if (scope) scope.setContext(name, context);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   configureScope(callback) {\n    const { scope, client } = this.getStackTop();\n    if (scope && client) {\n      callback(scope);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   run(callback) {\n    const oldHub = makeMain(this);\n    try {\n      callback(this);\n    } finally {\n      makeMain(oldHub);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getIntegration(integration) {\n    const client = this.getClient();\n    if (!client) return null;\n    try {\n      return client.getIntegration(integration);\n    } catch (_oO) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);\n      return null;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   startTransaction(context, customSamplingContext) {\n    return this._callExtensionMethod('startTransaction', context, customSamplingContext);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   traceHeaders() {\n    return this._callExtensionMethod('traceHeaders');\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureSession(endSession = false) {\n    // both send the update and pull the session from the scope\n    if (endSession) {\n      return this.endSession();\n    }\n\n    // only send the update\n    this._sendSessionUpdate();\n  }\n\n  /**\n   * @inheritDoc\n   */\n   endSession() {\n    const layer = this.getStackTop();\n    const scope = layer && layer.scope;\n    const session = scope && scope.getSession();\n    if (session) {\n      closeSession(session);\n    }\n    this._sendSessionUpdate();\n\n    // the session is over; take it off of the scope\n    if (scope) {\n      scope.setSession();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   startSession(context) {\n    const { scope, client } = this.getStackTop();\n    const { release, environment } = (client && client.getOptions()) || {};\n\n    // Will fetch userAgent if called from browser sdk\n    const { userAgent } = GLOBAL_OBJ.navigator || {};\n\n    const session = makeSession({\n      release,\n      environment,\n      ...(scope && { user: scope.getUser() }),\n      ...(userAgent && { userAgent }),\n      ...context,\n    });\n\n    if (scope) {\n      // End existing session if there's one\n      const currentSession = scope.getSession && scope.getSession();\n      if (currentSession && currentSession.status === 'ok') {\n        updateSession(currentSession, { status: 'exited' });\n      }\n      this.endSession();\n\n      // Afterwards we set the new session on the scope\n      scope.setSession(session);\n    }\n\n    return session;\n  }\n\n  /**\n   * Returns if default PII should be sent to Sentry and propagated in ourgoing requests\n   * when Tracing is used.\n   */\n   shouldSendDefaultPii() {\n    const client = this.getClient();\n    const options = client && client.getOptions();\n    return Boolean(options && options.sendDefaultPii);\n  }\n\n  /**\n   * Sends the current Session on the scope\n   */\n   _sendSessionUpdate() {\n    const { scope, client } = this.getStackTop();\n    if (!scope) return;\n\n    const session = scope.getSession();\n    if (session) {\n      if (client && client.captureSession) {\n        client.captureSession(session);\n      }\n    }\n  }\n\n  /**\n   * Internal helper function to call a method on the top client if it exists.\n   *\n   * @param method The method to call on the client.\n   * @param args Arguments to pass to the client function.\n   */\n   _withClient(callback) {\n    const { scope, client } = this.getStackTop();\n    if (client) {\n      callback(client, scope);\n    }\n  }\n\n  /**\n   * Calls global extension method and binding current instance to the function call\n   */\n  // @ts-ignore Function lacks ending return statement and return type does not include 'undefined'. ts(2366)\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n   _callExtensionMethod(method, ...args) {\n    const carrier = getMainCarrier();\n    const sentry = carrier.__SENTRY__;\n    if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n      return sentry.extensions[method].apply(this, args);\n    }\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);\n  }\n}\n\n/**\n * Returns the global shim registry.\n *\n * FIXME: This function is problematic, because despite always returning a valid Carrier,\n * it has an optional `__SENTRY__` property, which then in turn requires us to always perform an unnecessary check\n * at the call-site. We always access the carrier through this function, so we can guarantee that `__SENTRY__` is there.\n **/\nfunction getMainCarrier() {\n  GLOBAL_OBJ.__SENTRY__ = GLOBAL_OBJ.__SENTRY__ || {\n    extensions: {},\n    hub: undefined,\n  };\n  return GLOBAL_OBJ;\n}\n\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nfunction makeMain(hub) {\n  const registry = getMainCarrier();\n  const oldHub = getHubFromCarrier(registry);\n  setHubOnCarrier(registry, hub);\n  return oldHub;\n}\n\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n */\nfunction getCurrentHub() {\n  // Get main carrier (global for every environment)\n  const registry = getMainCarrier();\n\n  // If there's no hub, or its an old API, assign a new one\n  if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n    setHubOnCarrier(registry, new Hub());\n  }\n\n  // Prefer domains over global if they are there (applicable only to Node environment)\n  if (isNodeEnv()) {\n    return getHubFromActiveDomain(registry);\n  }\n  // Return hub that lives on a global object\n  return getHubFromCarrier(registry);\n}\n\n/**\n * Try to read the hub from an active domain, and fallback to the registry if one doesn't exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry) {\n  try {\n    const sentry = getMainCarrier().__SENTRY__;\n    const activeDomain = sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;\n\n    // If there's no active domain, just return global hub\n    if (!activeDomain) {\n      return getHubFromCarrier(registry);\n    }\n\n    // If there's no hub on current domain, or it's an old API, assign a new one\n    if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {\n      const registryHubTopStack = getHubFromCarrier(registry).getStackTop();\n      setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, Scope.clone(registryHubTopStack.scope)));\n    }\n\n    // Return hub that lives on a domain\n    return getHubFromCarrier(activeDomain);\n  } catch (_Oo) {\n    // Return hub that lives on a global object\n    return getHubFromCarrier(registry);\n  }\n}\n\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier) {\n  return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);\n}\n\n/**\n * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\nfunction getHubFromCarrier(carrier) {\n  return getGlobalSingleton('hub', () => new Hub(), carrier);\n}\n\n/**\n * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute\n * @param carrier object\n * @param hub Hub\n * @returns A boolean indicating success or failure\n */\nfunction setHubOnCarrier(carrier, hub) {\n  if (!carrier) return false;\n  const __SENTRY__ = (carrier.__SENTRY__ = carrier.__SENTRY__ || {});\n  __SENTRY__.hub = hub;\n  return true;\n}\n\nexport { API_VERSION, Hub, getCurrentHub, getHubFromCarrier, getMainCarrier, makeMain, setHubOnCarrier };\n//# sourceMappingURL=hub.js.map\n","import { isPlainObject, dateTimestampInSeconds, SyncPromise, logger, isThenable, arrayify, getGlobalSingleton } from '@sentry/utils';\nimport { updateSession } from './session.js';\n\n/**\n * Default value for maximum number of breadcrumbs added to an event.\n */\nconst DEFAULT_MAX_BREADCRUMBS = 100;\n\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nclass Scope  {\n  /** Flag if notifying is happening. */\n\n  /** Callback for client to receive scope changes. */\n\n  /** Callback list that will be called after {@link applyToEvent}. */\n\n  /** Array of breadcrumbs. */\n\n  /** User */\n\n  /** Tags */\n\n  /** Extra */\n\n  /** Contexts */\n\n  /** Attachments */\n\n  /**\n   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get\n   * sent to Sentry\n   */\n\n  /** Fingerprint */\n\n  /** Severity */\n  // eslint-disable-next-line deprecation/deprecation\n\n  /** Transaction Name */\n\n  /** Span */\n\n  /** Session */\n\n  /** Request Mode Session Status */\n\n  // NOTE: Any field which gets added here should get added not only to the constructor but also to the `clone` method.\n\n   constructor() {\n    this._notifyingListeners = false;\n    this._scopeListeners = [];\n    this._eventProcessors = [];\n    this._breadcrumbs = [];\n    this._attachments = [];\n    this._user = {};\n    this._tags = {};\n    this._extra = {};\n    this._contexts = {};\n    this._sdkProcessingMetadata = {};\n  }\n\n  /**\n   * Inherit values from the parent scope.\n   * @param scope to clone.\n   */\n   static clone(scope) {\n    const newScope = new Scope();\n    if (scope) {\n      newScope._breadcrumbs = [...scope._breadcrumbs];\n      newScope._tags = { ...scope._tags };\n      newScope._extra = { ...scope._extra };\n      newScope._contexts = { ...scope._contexts };\n      newScope._user = scope._user;\n      newScope._level = scope._level;\n      newScope._span = scope._span;\n      newScope._session = scope._session;\n      newScope._transactionName = scope._transactionName;\n      newScope._fingerprint = scope._fingerprint;\n      newScope._eventProcessors = [...scope._eventProcessors];\n      newScope._requestSession = scope._requestSession;\n      newScope._attachments = [...scope._attachments];\n      newScope._sdkProcessingMetadata = { ...scope._sdkProcessingMetadata };\n    }\n    return newScope;\n  }\n\n  /**\n   * Add internal on change listener. Used for sub SDKs that need to store the scope.\n   * @hidden\n   */\n   addScopeListener(callback) {\n    this._scopeListeners.push(callback);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   addEventProcessor(callback) {\n    this._eventProcessors.push(callback);\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setUser(user) {\n    this._user = user || {};\n    if (this._session) {\n      updateSession(this._session, { user });\n    }\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getUser() {\n    return this._user;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getRequestSession() {\n    return this._requestSession;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setRequestSession(requestSession) {\n    this._requestSession = requestSession;\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTags(tags) {\n    this._tags = {\n      ...this._tags,\n      ...tags,\n    };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTag(key, value) {\n    this._tags = { ...this._tags, [key]: value };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setExtras(extras) {\n    this._extra = {\n      ...this._extra,\n      ...extras,\n    };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setExtra(key, extra) {\n    this._extra = { ...this._extra, [key]: extra };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setFingerprint(fingerprint) {\n    this._fingerprint = fingerprint;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setLevel(\n    // eslint-disable-next-line deprecation/deprecation\n    level,\n  ) {\n    this._level = level;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTransactionName(name) {\n    this._transactionName = name;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setContext(key, context) {\n    if (context === null) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete this._contexts[key];\n    } else {\n      this._contexts[key] = context;\n    }\n\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setSpan(span) {\n    this._span = span;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getSpan() {\n    return this._span;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getTransaction() {\n    // Often, this span (if it exists at all) will be a transaction, but it's not guaranteed to be. Regardless, it will\n    // have a pointer to the currently-active transaction.\n    const span = this.getSpan();\n    return span && span.transaction;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setSession(session) {\n    if (!session) {\n      delete this._session;\n    } else {\n      this._session = session;\n    }\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getSession() {\n    return this._session;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   update(captureContext) {\n    if (!captureContext) {\n      return this;\n    }\n\n    if (typeof captureContext === 'function') {\n      const updatedScope = (captureContext )(this);\n      return updatedScope instanceof Scope ? updatedScope : this;\n    }\n\n    if (captureContext instanceof Scope) {\n      this._tags = { ...this._tags, ...captureContext._tags };\n      this._extra = { ...this._extra, ...captureContext._extra };\n      this._contexts = { ...this._contexts, ...captureContext._contexts };\n      if (captureContext._user && Object.keys(captureContext._user).length) {\n        this._user = captureContext._user;\n      }\n      if (captureContext._level) {\n        this._level = captureContext._level;\n      }\n      if (captureContext._fingerprint) {\n        this._fingerprint = captureContext._fingerprint;\n      }\n      if (captureContext._requestSession) {\n        this._requestSession = captureContext._requestSession;\n      }\n    } else if (isPlainObject(captureContext)) {\n      // eslint-disable-next-line no-param-reassign\n      captureContext = captureContext ;\n      this._tags = { ...this._tags, ...captureContext.tags };\n      this._extra = { ...this._extra, ...captureContext.extra };\n      this._contexts = { ...this._contexts, ...captureContext.contexts };\n      if (captureContext.user) {\n        this._user = captureContext.user;\n      }\n      if (captureContext.level) {\n        this._level = captureContext.level;\n      }\n      if (captureContext.fingerprint) {\n        this._fingerprint = captureContext.fingerprint;\n      }\n      if (captureContext.requestSession) {\n        this._requestSession = captureContext.requestSession;\n      }\n    }\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   clear() {\n    this._breadcrumbs = [];\n    this._tags = {};\n    this._extra = {};\n    this._user = {};\n    this._contexts = {};\n    this._level = undefined;\n    this._transactionName = undefined;\n    this._fingerprint = undefined;\n    this._requestSession = undefined;\n    this._span = undefined;\n    this._session = undefined;\n    this._notifyScopeListeners();\n    this._attachments = [];\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   addBreadcrumb(breadcrumb, maxBreadcrumbs) {\n    const maxCrumbs = typeof maxBreadcrumbs === 'number' ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS;\n\n    // No data has been changed, so don't notify scope listeners\n    if (maxCrumbs <= 0) {\n      return this;\n    }\n\n    const mergedBreadcrumb = {\n      timestamp: dateTimestampInSeconds(),\n      ...breadcrumb,\n    };\n    this._breadcrumbs = [...this._breadcrumbs, mergedBreadcrumb].slice(-maxCrumbs);\n    this._notifyScopeListeners();\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getLastBreadcrumb() {\n    return this._breadcrumbs[this._breadcrumbs.length - 1];\n  }\n\n  /**\n   * @inheritDoc\n   */\n   clearBreadcrumbs() {\n    this._breadcrumbs = [];\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   addAttachment(attachment) {\n    this._attachments.push(attachment);\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getAttachments() {\n    return this._attachments;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   clearAttachments() {\n    this._attachments = [];\n    return this;\n  }\n\n  /**\n   * Applies data from the scope to the event and runs all event processors on it.\n   *\n   * @param event Event\n   * @param hint Object containing additional information about the original exception, for use by the event processors.\n   * @hidden\n   */\n   applyToEvent(event, hint = {}) {\n    if (this._extra && Object.keys(this._extra).length) {\n      event.extra = { ...this._extra, ...event.extra };\n    }\n    if (this._tags && Object.keys(this._tags).length) {\n      event.tags = { ...this._tags, ...event.tags };\n    }\n    if (this._user && Object.keys(this._user).length) {\n      event.user = { ...this._user, ...event.user };\n    }\n    if (this._contexts && Object.keys(this._contexts).length) {\n      event.contexts = { ...this._contexts, ...event.contexts };\n    }\n    if (this._level) {\n      event.level = this._level;\n    }\n    if (this._transactionName) {\n      event.transaction = this._transactionName;\n    }\n\n    // We want to set the trace context for normal events only if there isn't already\n    // a trace context on the event. There is a product feature in place where we link\n    // errors with transaction and it relies on that.\n    if (this._span) {\n      event.contexts = { trace: this._span.getTraceContext(), ...event.contexts };\n      const transactionName = this._span.transaction && this._span.transaction.name;\n      if (transactionName) {\n        event.tags = { transaction: transactionName, ...event.tags };\n      }\n    }\n\n    this._applyFingerprint(event);\n\n    event.breadcrumbs = [...(event.breadcrumbs || []), ...this._breadcrumbs];\n    event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n\n    event.sdkProcessingMetadata = { ...event.sdkProcessingMetadata, ...this._sdkProcessingMetadata };\n\n    return this._notifyEventProcessors([...getGlobalEventProcessors(), ...this._eventProcessors], event, hint);\n  }\n\n  /**\n   * Add data which will be accessible during event processing but won't get sent to Sentry\n   */\n   setSDKProcessingMetadata(newData) {\n    this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...newData };\n\n    return this;\n  }\n\n  /**\n   * This will be called after {@link applyToEvent} is finished.\n   */\n   _notifyEventProcessors(\n    processors,\n    event,\n    hint,\n    index = 0,\n  ) {\n    return new SyncPromise((resolve, reject) => {\n      const processor = processors[index];\n      if (event === null || typeof processor !== 'function') {\n        resolve(event);\n      } else {\n        const result = processor({ ...event }, hint) ;\n\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n          processor.id &&\n          result === null &&\n          logger.log(`Event processor \"${processor.id}\" dropped event`);\n\n        if (isThenable(result)) {\n          void result\n            .then(final => this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve))\n            .then(null, reject);\n        } else {\n          void this._notifyEventProcessors(processors, result, hint, index + 1)\n            .then(resolve)\n            .then(null, reject);\n        }\n      }\n    });\n  }\n\n  /**\n   * This will be called on every set call.\n   */\n   _notifyScopeListeners() {\n    // We need this check for this._notifyingListeners to be able to work on scope during updates\n    // If this check is not here we'll produce endless recursion when something is done with the scope\n    // during the callback.\n    if (!this._notifyingListeners) {\n      this._notifyingListeners = true;\n      this._scopeListeners.forEach(callback => {\n        callback(this);\n      });\n      this._notifyingListeners = false;\n    }\n  }\n\n  /**\n   * Applies fingerprint from the scope to the event if there's one,\n   * uses message if there's one instead or get rid of empty fingerprint\n   */\n   _applyFingerprint(event) {\n    // Make sure it's an array first and we actually have something in place\n    event.fingerprint = event.fingerprint ? arrayify(event.fingerprint) : [];\n\n    // If we have something on the scope, then merge it with event\n    if (this._fingerprint) {\n      event.fingerprint = event.fingerprint.concat(this._fingerprint);\n    }\n\n    // If we have no data at all, remove empty array default\n    if (event.fingerprint && !event.fingerprint.length) {\n      delete event.fingerprint;\n    }\n  }\n}\n\n/**\n * Returns the global event processors.\n */\nfunction getGlobalEventProcessors() {\n  return getGlobalSingleton('globalEventProcessors', () => []);\n}\n\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nfunction addGlobalEventProcessor(callback) {\n  getGlobalEventProcessors().push(callback);\n}\n\nexport { Scope, addGlobalEventProcessor };\n//# sourceMappingURL=scope.js.map\n","import { timestampInSeconds, uuid4, dropUndefinedKeys } from '@sentry/utils';\n\n/**\n * Creates a new `Session` object by setting certain default parameters. If optional @param context\n * is passed, the passed properties are applied to the session object.\n *\n * @param context (optional) additional properties to be applied to the returned session object\n *\n * @returns a new `Session` object\n */\nfunction makeSession(context) {\n  // Both timestamp and started are in seconds since the UNIX epoch.\n  const startingTime = timestampInSeconds();\n\n  const session = {\n    sid: uuid4(),\n    init: true,\n    timestamp: startingTime,\n    started: startingTime,\n    duration: 0,\n    status: 'ok',\n    errors: 0,\n    ignoreDuration: false,\n    toJSON: () => sessionToJSON(session),\n  };\n\n  if (context) {\n    updateSession(session, context);\n  }\n\n  return session;\n}\n\n/**\n * Updates a session object with the properties passed in the context.\n *\n * Note that this function mutates the passed object and returns void.\n * (Had to do this instead of returning a new and updated session because closing and sending a session\n * makes an update to the session after it was passed to the sending logic.\n * @see BaseClient.captureSession )\n *\n * @param session the `Session` to update\n * @param context the `SessionContext` holding the properties that should be updated in @param session\n */\n// eslint-disable-next-line complexity\nfunction updateSession(session, context = {}) {\n  if (context.user) {\n    if (!session.ipAddress && context.user.ip_address) {\n      session.ipAddress = context.user.ip_address;\n    }\n\n    if (!session.did && !context.did) {\n      session.did = context.user.id || context.user.email || context.user.username;\n    }\n  }\n\n  session.timestamp = context.timestamp || timestampInSeconds();\n\n  if (context.ignoreDuration) {\n    session.ignoreDuration = context.ignoreDuration;\n  }\n  if (context.sid) {\n    // Good enough uuid validation. — Kamil\n    session.sid = context.sid.length === 32 ? context.sid : uuid4();\n  }\n  if (context.init !== undefined) {\n    session.init = context.init;\n  }\n  if (!session.did && context.did) {\n    session.did = `${context.did}`;\n  }\n  if (typeof context.started === 'number') {\n    session.started = context.started;\n  }\n  if (session.ignoreDuration) {\n    session.duration = undefined;\n  } else if (typeof context.duration === 'number') {\n    session.duration = context.duration;\n  } else {\n    const duration = session.timestamp - session.started;\n    session.duration = duration >= 0 ? duration : 0;\n  }\n  if (context.release) {\n    session.release = context.release;\n  }\n  if (context.environment) {\n    session.environment = context.environment;\n  }\n  if (!session.ipAddress && context.ipAddress) {\n    session.ipAddress = context.ipAddress;\n  }\n  if (!session.userAgent && context.userAgent) {\n    session.userAgent = context.userAgent;\n  }\n  if (typeof context.errors === 'number') {\n    session.errors = context.errors;\n  }\n  if (context.status) {\n    session.status = context.status;\n  }\n}\n\n/**\n * Closes a session by setting its status and updating the session object with it.\n * Internally calls `updateSession` to update the passed session object.\n *\n * Note that this function mutates the passed session (@see updateSession for explanation).\n *\n * @param session the `Session` object to be closed\n * @param status the `SessionStatus` with which the session was closed. If you don't pass a status,\n *               this function will keep the previously set status, unless it was `'ok'` in which case\n *               it is changed to `'exited'`.\n */\nfunction closeSession(session, status) {\n  let context = {};\n  if (status) {\n    context = { status };\n  } else if (session.status === 'ok') {\n    context = { status: 'exited' };\n  }\n\n  updateSession(session, context);\n}\n\n/**\n * Serializes a passed session object to a JSON object with a slightly different structure.\n * This is necessary because the Sentry backend requires a slightly different schema of a session\n * than the one the JS SDKs use internally.\n *\n * @param session the session to be converted\n *\n * @returns a JSON object of the passed session\n */\nfunction sessionToJSON(session) {\n  return dropUndefinedKeys({\n    sid: `${session.sid}`,\n    init: session.init,\n    // Make sure that sec is converted to ms for date constructor\n    started: new Date(session.started * 1000).toISOString(),\n    timestamp: new Date(session.timestamp * 1000).toISOString(),\n    status: session.status,\n    errors: session.errors,\n    did: typeof session.did === 'number' || typeof session.did === 'string' ? `${session.did}` : undefined,\n    duration: session.duration,\n    attrs: {\n      release: session.release,\n      environment: session.environment,\n      ip_address: session.ipAddress,\n      user_agent: session.userAgent,\n    },\n  });\n}\n\nexport { closeSession, makeSession, updateSession };\n//# sourceMappingURL=session.js.map\n","import { isString } from './is.js';\nimport { getGlobalObject } from './worldwide.js';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject();\n\nconst DEFAULT_MAX_STRING_LENGTH = 80;\n\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction htmlTreeAsString(\n  elem,\n  options = {},\n) {\n\n  // try/catch both:\n  // - accessing event.target (see getsentry/raven-js#838, #768)\n  // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n  // - can throw an exception in some circumstances.\n  try {\n    let currentElem = elem ;\n    const MAX_TRAVERSE_HEIGHT = 5;\n    const out = [];\n    let height = 0;\n    let len = 0;\n    const separator = ' > ';\n    const sepLength = separator.length;\n    let nextStr;\n    const keyAttrs = Array.isArray(options) ? options : options.keyAttrs;\n    const maxStringLength = (!Array.isArray(options) && options.maxStringLength) || DEFAULT_MAX_STRING_LENGTH;\n\n    while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n      nextStr = _htmlElementAsString(currentElem, keyAttrs);\n      // bail out if\n      // - nextStr is the 'html' element\n      // - the length of the string that would be created exceeds maxStringLength\n      //   (ignore this limit if we are on the first iteration)\n      if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= maxStringLength)) {\n        break;\n      }\n\n      out.push(nextStr);\n\n      len += nextStr.length;\n      currentElem = currentElem.parentNode;\n    }\n\n    return out.reverse().join(separator);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction _htmlElementAsString(el, keyAttrs) {\n  const elem = el\n\n;\n\n  const out = [];\n  let className;\n  let classes;\n  let key;\n  let attr;\n  let i;\n\n  if (!elem || !elem.tagName) {\n    return '';\n  }\n\n  out.push(elem.tagName.toLowerCase());\n\n  // Pairs of attribute keys defined in `serializeAttribute` and their values on element.\n  const keyAttrPairs =\n    keyAttrs && keyAttrs.length\n      ? keyAttrs.filter(keyAttr => elem.getAttribute(keyAttr)).map(keyAttr => [keyAttr, elem.getAttribute(keyAttr)])\n      : null;\n\n  if (keyAttrPairs && keyAttrPairs.length) {\n    keyAttrPairs.forEach(keyAttrPair => {\n      out.push(`[${keyAttrPair[0]}=\"${keyAttrPair[1]}\"]`);\n    });\n  } else {\n    if (elem.id) {\n      out.push(`#${elem.id}`);\n    }\n\n    // eslint-disable-next-line prefer-const\n    className = elem.className;\n    if (className && isString(className)) {\n      classes = className.split(/\\s+/);\n      for (i = 0; i < classes.length; i++) {\n        out.push(`.${classes[i]}`);\n      }\n    }\n  }\n  const allowedAttrs = ['aria-label', 'type', 'name', 'title', 'alt'];\n  for (i = 0; i < allowedAttrs.length; i++) {\n    key = allowedAttrs[i];\n    attr = elem.getAttribute(key);\n    if (attr) {\n      out.push(`[${key}=\"${attr}\"]`);\n    }\n  }\n  return out.join('');\n}\n\n/**\n * A safe form of location.href\n */\nfunction getLocationHref() {\n  try {\n    return WINDOW.document.location.href;\n  } catch (oO) {\n    return '';\n  }\n}\n\n/**\n * Gets a DOM element by using document.querySelector.\n *\n * This wrapper will first check for the existance of the function before\n * actually calling it so that we don't have to take care of this check,\n * every time we want to access the DOM.\n *\n * Reason: DOM/querySelector is not available in all environments.\n *\n * We have to cast to any because utils can be consumed by a variety of environments,\n * and we don't want to break TS users. If you know what element will be selected by\n * `document.querySelector`, specify it as part of the generic call. For example,\n * `const element = getDomElement<Element>('selector');`\n *\n * @param selector the selector string passed on to document.querySelector\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction getDomElement(selector) {\n  if (WINDOW.document && WINDOW.document.querySelector) {\n    return WINDOW.document.querySelector(selector) ;\n  }\n  return null;\n}\n\nexport { getDomElement, getLocationHref, htmlTreeAsString };\n//# sourceMappingURL=browser.js.map\n","/*\n * This module exists for optimizations in the build process through rollup and terser.  We define some global\n * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these\n * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will\n * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to\n * `logger` and preventing node-related code from appearing in browser bundles.\n *\n * Attention:\n * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by\n * users. These flags should live in their respective packages, as we identified user tooling (specifically webpack)\n * having issues tree-shaking these constants across package boundaries.\n * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want\n * users to be able to shake away expressions that it guards.\n */\n\n/**\n * Figures out if we're building a browser bundle.\n *\n * @returns true if this is a browser bundle build.\n */\nfunction isBrowserBundle() {\n  return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;\n}\n\n/**\n * Get source of SDK.\n */\nfunction getSDKSource() {\n  // @ts-ignore \"npm\" is injected by rollup during build process\n  return \"npm\";\n}\n\nexport { getSDKSource, isBrowserBundle };\n//# sourceMappingURL=env.js.map\n","// eslint-disable-next-line @typescript-eslint/unbound-method\nconst objectToString = Object.prototype.toString;\n\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isError(wat) {\n  switch (objectToString.call(wat)) {\n    case '[object Error]':\n    case '[object Exception]':\n    case '[object DOMException]':\n      return true;\n    default:\n      return isInstanceOf(wat, Error);\n  }\n}\n/**\n * Checks whether given value is an instance of the given built-in class.\n *\n * @param wat The value to be checked\n * @param className\n * @returns A boolean representing the result.\n */\nfunction isBuiltin(wat, className) {\n  return objectToString.call(wat) === `[object ${className}]`;\n}\n\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isErrorEvent(wat) {\n  return isBuiltin(wat, 'ErrorEvent');\n}\n\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isDOMError(wat) {\n  return isBuiltin(wat, 'DOMError');\n}\n\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isDOMException(wat) {\n  return isBuiltin(wat, 'DOMException');\n}\n\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isString(wat) {\n  return isBuiltin(wat, 'String');\n}\n\n/**\n * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isPrimitive(wat) {\n  return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n\n/**\n * Checks whether given value's type is an object literal\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isPlainObject(wat) {\n  return isBuiltin(wat, 'Object');\n}\n\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isEvent(wat) {\n  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isElement(wat) {\n  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isRegExp(wat) {\n  return isBuiltin(wat, 'RegExp');\n}\n\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nfunction isThenable(wat) {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return Boolean(wat && wat.then && typeof wat.then === 'function');\n}\n\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isSyntheticEvent(wat) {\n  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n\n/**\n * Checks whether given value is NaN\n * {@link isNaN}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isNaN(wat) {\n  return typeof wat === 'number' && wat !== wat;\n}\n\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nfunction isInstanceOf(wat, base) {\n  try {\n    return wat instanceof base;\n  } catch (_e) {\n    return false;\n  }\n}\n\nexport { isDOMError, isDOMException, isElement, isError, isErrorEvent, isEvent, isInstanceOf, isNaN, isPlainObject, isPrimitive, isRegExp, isString, isSyntheticEvent, isThenable };\n//# sourceMappingURL=is.js.map\n","import { getGlobalSingleton, GLOBAL_OBJ } from './worldwide.js';\n\n/** Prefix for logging strings */\nconst PREFIX = 'Sentry Logger ';\n\nconst CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert', 'trace'] ;\n\n/**\n * Temporarily disable sentry console instrumentations.\n *\n * @param callback The function to run against the original `console` messages\n * @returns The results of the callback\n */\nfunction consoleSandbox(callback) {\n  if (!('console' in GLOBAL_OBJ)) {\n    return callback();\n  }\n\n  const originalConsole = GLOBAL_OBJ.console ;\n  const wrappedLevels = {};\n\n  // Restore all wrapped console methods\n  CONSOLE_LEVELS.forEach(level => {\n    // TODO(v7): Remove this check as it's only needed for Node 6\n    const originalWrappedFunc =\n      originalConsole[level] && (originalConsole[level] ).__sentry_original__;\n    if (level in originalConsole && originalWrappedFunc) {\n      wrappedLevels[level] = originalConsole[level] ;\n      originalConsole[level] = originalWrappedFunc ;\n    }\n  });\n\n  try {\n    return callback();\n  } finally {\n    // Revert restoration to wrapped state\n    Object.keys(wrappedLevels).forEach(level => {\n      originalConsole[level] = wrappedLevels[level ];\n    });\n  }\n}\n\nfunction makeLogger() {\n  let enabled = false;\n  const logger = {\n    enable: () => {\n      enabled = true;\n    },\n    disable: () => {\n      enabled = false;\n    },\n  };\n\n  if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n    CONSOLE_LEVELS.forEach(name => {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      logger[name] = (...args) => {\n        if (enabled) {\n          consoleSandbox(() => {\n            GLOBAL_OBJ.console[name](`${PREFIX}[${name}]:`, ...args);\n          });\n        }\n      };\n    });\n  } else {\n    CONSOLE_LEVELS.forEach(name => {\n      logger[name] = () => undefined;\n    });\n  }\n\n  return logger ;\n}\n\n// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\nlet logger;\nif ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n  logger = getGlobalSingleton('logger', makeLogger);\n} else {\n  logger = makeLogger();\n}\n\nexport { CONSOLE_LEVELS, consoleSandbox, logger };\n//# sourceMappingURL=logger.js.map\n","import { addNonEnumerableProperty } from './object.js';\nimport { snipLine } from './string.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nfunction uuid4() {\n  const gbl = GLOBAL_OBJ ;\n  const crypto = gbl.crypto || gbl.msCrypto;\n\n  if (crypto && crypto.randomUUID) {\n    return crypto.randomUUID().replace(/-/g, '');\n  }\n\n  const getRandomByte =\n    crypto && crypto.getRandomValues ? () => crypto.getRandomValues(new Uint8Array(1))[0] : () => Math.random() * 16;\n\n  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n  // Concatenating the following numbers as strings results in '10000000100040008000100000000000'\n  return (([1e7] ) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>\n    // eslint-disable-next-line no-bitwise\n    ((c ) ^ ((getRandomByte() & 15) >> ((c ) / 4))).toString(16),\n  );\n}\n\nfunction getFirstException(event) {\n  return event.exception && event.exception.values ? event.exception.values[0] : undefined;\n}\n\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nfunction getEventDescription(event) {\n  const { message, event_id: eventId } = event;\n  if (message) {\n    return message;\n  }\n\n  const firstException = getFirstException(event);\n  if (firstException) {\n    if (firstException.type && firstException.value) {\n      return `${firstException.type}: ${firstException.value}`;\n    }\n    return firstException.type || firstException.value || eventId || '<unknown>';\n  }\n  return eventId || '<unknown>';\n}\n\n/**\n * Adds exception values, type and value to an synthetic Exception.\n * @param event The event to modify.\n * @param value Value of the exception.\n * @param type Type of the exception.\n * @hidden\n */\nfunction addExceptionTypeValue(event, value, type) {\n  const exception = (event.exception = event.exception || {});\n  const values = (exception.values = exception.values || []);\n  const firstException = (values[0] = values[0] || {});\n  if (!firstException.value) {\n    firstException.value = value || '';\n  }\n  if (!firstException.type) {\n    firstException.type = type || 'Error';\n  }\n}\n\n/**\n * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.\n *\n * @param event The event to modify.\n * @param newMechanism Mechanism data to add to the event.\n * @hidden\n */\nfunction addExceptionMechanism(event, newMechanism) {\n  const firstException = getFirstException(event);\n  if (!firstException) {\n    return;\n  }\n\n  const defaultMechanism = { type: 'generic', handled: true };\n  const currentMechanism = firstException.mechanism;\n  firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };\n\n  if (newMechanism && 'data' in newMechanism) {\n    const mergedData = { ...(currentMechanism && currentMechanism.data), ...newMechanism.data };\n    firstException.mechanism.data = mergedData;\n  }\n}\n\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nconst SEMVER_REGEXP =\n  /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n\n/**\n * Represents Semantic Versioning object\n */\n\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nfunction parseSemver(input) {\n  const match = input.match(SEMVER_REGEXP) || [];\n  const major = parseInt(match[1], 10);\n  const minor = parseInt(match[2], 10);\n  const patch = parseInt(match[3], 10);\n  return {\n    buildmetadata: match[5],\n    major: isNaN(major) ? undefined : major,\n    minor: isNaN(minor) ? undefined : minor,\n    patch: isNaN(patch) ? undefined : patch,\n    prerelease: match[4],\n  };\n}\n\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nfunction addContextToFrame(lines, frame, linesOfContext = 5) {\n  // When there is no line number in the frame, attaching context is nonsensical and will even break grouping\n  if (frame.lineno === undefined) {\n    return;\n  }\n\n  const maxLines = lines.length;\n  const sourceLine = Math.max(Math.min(maxLines, frame.lineno - 1), 0);\n\n  frame.pre_context = lines\n    .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n    .map((line) => snipLine(line, 0));\n\n  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n\n  frame.post_context = lines\n    .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n    .map((line) => snipLine(line, 0));\n}\n\n/**\n * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object\n * in question), and marks it captured if not.\n *\n * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and\n * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so\n * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because\n * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not\n * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This\n * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we\n * see it.\n *\n * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on\n * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent\n * object wrapper forms so that this check will always work. However, because we need to flag the exact object which\n * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification\n * must be done before the exception captured.\n *\n * @param A thrown exception to check or flag as having been seen\n * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)\n */\nfunction checkOrSetAlreadyCaught(exception) {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  if (exception && (exception ).__sentry_captured__) {\n    return true;\n  }\n\n  try {\n    // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the\n    // `ExtraErrorData` integration\n    addNonEnumerableProperty(exception , '__sentry_captured__', true);\n  } catch (err) {\n    // `exception` is a primitive, so we can't mark it seen\n  }\n\n  return false;\n}\n\n/**\n * Checks whether the given input is already an array, and if it isn't, wraps it in one.\n *\n * @param maybeArray Input to turn into an array, if necessary\n * @returns The input, if already an array, or an array with the input as the only element, if not\n */\nfunction arrayify(maybeArray) {\n  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];\n}\n\nexport { addContextToFrame, addExceptionMechanism, addExceptionTypeValue, arrayify, checkOrSetAlreadyCaught, getEventDescription, parseSemver, uuid4 };\n//# sourceMappingURL=misc.js.map\n","import { isBrowserBundle } from './env.js';\n\n/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.\n */\n\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nfunction isNodeEnv() {\n  // explicitly check for browser bundles as those can be optimized statically\n  // by terser/rollup.\n  return (\n    !isBrowserBundle() &&\n    Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'\n  );\n}\n\n/**\n * Requires a module which is protected against bundler minification.\n *\n * @param request The module path to resolve\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any\nfunction dynamicRequire(mod, request) {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return mod.require(request);\n}\n\n/**\n * Helper for dynamically loading module that should work with linked dependencies.\n * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`\n * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during\n * build time. `require.resolve` is also not available in any other way, so we cannot create,\n * a fake helper like we do with `dynamicRequire`.\n *\n * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.\n * That is to mimic the behavior of `require.resolve` exactly.\n *\n * @param moduleName module name to require\n * @returns possibly required module\n */\nfunction loadModule(moduleName) {\n  let mod;\n\n  try {\n    mod = dynamicRequire(module, moduleName);\n  } catch (e) {\n    // no-empty\n  }\n\n  try {\n    const { cwd } = dynamicRequire(module, 'process');\n    mod = dynamicRequire(module, `${cwd()}/node_modules/${moduleName}`) ;\n  } catch (e) {\n    // no-empty\n  }\n\n  return mod;\n}\n\nexport { dynamicRequire, isNodeEnv, loadModule };\n//# sourceMappingURL=node.js.map\n","import { htmlTreeAsString } from './browser.js';\nimport { isError, isEvent, isInstanceOf, isElement, isPlainObject, isPrimitive } from './is.js';\nimport { truncate } from './string.js';\n\n/**\n * Replace a method in an object with a wrapped version of itself.\n *\n * @param source An object that contains a method to be wrapped.\n * @param name The name of the method to be wrapped.\n * @param replacementFactory A higher-order function that takes the original version of the given method and returns a\n * wrapped version. Note: The function returned by `replacementFactory` needs to be a non-arrow function, in order to\n * preserve the correct value of `this`, and the original method must be called using `origMethod.call(this, <other\n * args>)` or `origMethod.apply(this, [<other args>])` (rather than being called directly), again to preserve `this`.\n * @returns void\n */\nfunction fill(source, name, replacementFactory) {\n  if (!(name in source)) {\n    return;\n  }\n\n  const original = source[name] ;\n  const wrapped = replacementFactory(original) ;\n\n  // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n  // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n  if (typeof wrapped === 'function') {\n    try {\n      markFunctionWrapped(wrapped, original);\n    } catch (_Oo) {\n      // This can throw if multiple fill happens on a global object like XMLHttpRequest\n      // Fixes https://github.com/getsentry/sentry-javascript/issues/2043\n    }\n  }\n\n  source[name] = wrapped;\n}\n\n/**\n * Defines a non-enumerable property on the given object.\n *\n * @param obj The object on which to set the property\n * @param name The name of the property to be set\n * @param value The value to which to set the property\n */\nfunction addNonEnumerableProperty(obj, name, value) {\n  Object.defineProperty(obj, name, {\n    // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it\n    value: value,\n    writable: true,\n    configurable: true,\n  });\n}\n\n/**\n * Remembers the original function on the wrapped function and\n * patches up the prototype.\n *\n * @param wrapped the wrapper function\n * @param original the original function that gets wrapped\n */\nfunction markFunctionWrapped(wrapped, original) {\n  const proto = original.prototype || {};\n  wrapped.prototype = original.prototype = proto;\n  addNonEnumerableProperty(wrapped, '__sentry_original__', original);\n}\n\n/**\n * This extracts the original function if available.  See\n * `markFunctionWrapped` for more information.\n *\n * @param func the function to unwrap\n * @returns the unwrapped version of the function if available.\n */\nfunction getOriginalFunction(func) {\n  return func.__sentry_original__;\n}\n\n/**\n * Encodes given object into url-friendly format\n *\n * @param object An object that contains serializable values\n * @returns string Encoded\n */\nfunction urlEncode(object) {\n  return Object.keys(object)\n    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(object[key])}`)\n    .join('&');\n}\n\n/**\n * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their\n * non-enumerable properties attached.\n *\n * @param value Initial source that we have to transform in order for it to be usable by the serializer\n * @returns An Event or Error turned into an object - or the value argurment itself, when value is neither an Event nor\n *  an Error.\n */\nfunction convertToPlainObject(value)\n\n {\n  if (isError(value)) {\n    return {\n      message: value.message,\n      name: value.name,\n      stack: value.stack,\n      ...getOwnProperties(value),\n    };\n  } else if (isEvent(value)) {\n    const newObj\n\n = {\n      type: value.type,\n      target: serializeEventTarget(value.target),\n      currentTarget: serializeEventTarget(value.currentTarget),\n      ...getOwnProperties(value),\n    };\n\n    if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n      newObj.detail = value.detail;\n    }\n\n    return newObj;\n  } else {\n    return value;\n  }\n}\n\n/** Creates a string representation of the target of an `Event` object */\nfunction serializeEventTarget(target) {\n  try {\n    return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/** Filters out all but an object's own properties */\nfunction getOwnProperties(obj) {\n  if (typeof obj === 'object' && obj !== null) {\n    const extractedProps = {};\n    for (const property in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, property)) {\n        extractedProps[property] = (obj )[property];\n      }\n    }\n    return extractedProps;\n  } else {\n    return {};\n  }\n}\n\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\nfunction extractExceptionKeysForMessage(exception, maxLength = 40) {\n  const keys = Object.keys(convertToPlainObject(exception));\n  keys.sort();\n\n  if (!keys.length) {\n    return '[object has no keys]';\n  }\n\n  if (keys[0].length >= maxLength) {\n    return truncate(keys[0], maxLength);\n  }\n\n  for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n    const serialized = keys.slice(0, includedKeys).join(', ');\n    if (serialized.length > maxLength) {\n      continue;\n    }\n    if (includedKeys === keys.length) {\n      return serialized;\n    }\n    return truncate(serialized, maxLength);\n  }\n\n  return '';\n}\n\n/**\n * Given any object, return a new object having removed all fields whose value was `undefined`.\n * Works recursively on objects and arrays.\n *\n * Attention: This function keeps circular references in the returned object.\n */\nfunction dropUndefinedKeys(inputValue) {\n  // This map keeps track of what already visited nodes map to.\n  // Our Set - based memoBuilder doesn't work here because we want to the output object to have the same circular\n  // references as the input object.\n  const memoizationMap = new Map();\n\n  // This function just proxies `_dropUndefinedKeys` to keep the `memoBuilder` out of this function's API\n  return _dropUndefinedKeys(inputValue, memoizationMap);\n}\n\nfunction _dropUndefinedKeys(inputValue, memoizationMap) {\n  if (isPlainObject(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the object it was mapped to in the new object\n    const memoVal = memoizationMap.get(inputValue);\n    if (memoVal !== undefined) {\n      return memoVal ;\n    }\n\n    const returnValue = {};\n    // Store the mapping of this value in case we visit it again, in case of circular data\n    memoizationMap.set(inputValue, returnValue);\n\n    for (const key of Object.keys(inputValue)) {\n      if (typeof inputValue[key] !== 'undefined') {\n        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);\n      }\n    }\n\n    return returnValue ;\n  }\n\n  if (Array.isArray(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the array it was mapped to in the new object\n    const memoVal = memoizationMap.get(inputValue);\n    if (memoVal !== undefined) {\n      return memoVal ;\n    }\n\n    const returnValue = [];\n    // Store the mapping of this value in case we visit it again, in case of circular data\n    memoizationMap.set(inputValue, returnValue);\n\n    inputValue.forEach((item) => {\n      returnValue.push(_dropUndefinedKeys(item, memoizationMap));\n    });\n\n    return returnValue ;\n  }\n\n  return inputValue;\n}\n\n/**\n * Ensure that something is an object.\n *\n * Turns `undefined` and `null` into `String`s and all other primitives into instances of their respective wrapper\n * classes (String, Boolean, Number, etc.). Acts as the identity function on non-primitives.\n *\n * @param wat The subject of the objectification\n * @returns A version of `wat` which can safely be used with `Object` class methods\n */\nfunction objectify(wat) {\n  let objectified;\n  switch (true) {\n    case wat === undefined || wat === null:\n      objectified = new String(wat);\n      break;\n\n    // Though symbols and bigints do have wrapper classes (`Symbol` and `BigInt`, respectively), for whatever reason\n    // those classes don't have constructors which can be used with the `new` keyword. We therefore need to cast each as\n    // an object in order to wrap it.\n    case typeof wat === 'symbol' || typeof wat === 'bigint':\n      objectified = Object(wat);\n      break;\n\n    // this will catch the remaining primitives: `String`, `Number`, and `Boolean`\n    case isPrimitive(wat):\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      objectified = new (wat ).constructor(wat);\n      break;\n\n    // by process of elimination, at this point we know that `wat` must already be an object\n    default:\n      objectified = wat;\n      break;\n  }\n  return objectified;\n}\n\nexport { addNonEnumerableProperty, convertToPlainObject, dropUndefinedKeys, extractExceptionKeysForMessage, fill, getOriginalFunction, markFunctionWrapped, objectify, urlEncode };\n//# sourceMappingURL=object.js.map\n","import { isString, isRegExp } from './is.js';\n\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string (0 = unlimited)\n * @returns string Encoded\n */\nfunction truncate(str, max = 0) {\n  if (typeof str !== 'string' || max === 0) {\n    return str;\n  }\n  return str.length <= max ? str : `${str.slice(0, max)}...`;\n}\n\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nfunction snipLine(line, colno) {\n  let newLine = line;\n  const lineLength = newLine.length;\n  if (lineLength <= 150) {\n    return newLine;\n  }\n  if (colno > lineLength) {\n    // eslint-disable-next-line no-param-reassign\n    colno = lineLength;\n  }\n\n  let start = Math.max(colno - 60, 0);\n  if (start < 5) {\n    start = 0;\n  }\n\n  let end = Math.min(start + 140, lineLength);\n  if (end > lineLength - 5) {\n    end = lineLength;\n  }\n  if (end === lineLength) {\n    start = Math.max(end - 140, 0);\n  }\n\n  newLine = newLine.slice(start, end);\n  if (start > 0) {\n    newLine = `'{snip} ${newLine}`;\n  }\n  if (end < lineLength) {\n    newLine += ' {snip}';\n  }\n\n  return newLine;\n}\n\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction safeJoin(input, delimiter) {\n  if (!Array.isArray(input)) {\n    return '';\n  }\n\n  const output = [];\n  // eslint-disable-next-line @typescript-eslint/prefer-for-of\n  for (let i = 0; i < input.length; i++) {\n    const value = input[i];\n    try {\n      output.push(String(value));\n    } catch (e) {\n      output.push('[value cannot be serialized]');\n    }\n  }\n\n  return output.join(delimiter);\n}\n\n/**\n * Checks if the given value matches a regex or string\n *\n * @param value The string to test\n * @param pattern Either a regex or a string against which `value` will be matched\n * @param requireExactStringMatch If true, `value` must match `pattern` exactly. If false, `value` will match\n * `pattern` if it contains `pattern`. Only applies to string-type patterns.\n */\nfunction isMatchingPattern(\n  value,\n  pattern,\n  requireExactStringMatch = false,\n) {\n  if (!isString(value)) {\n    return false;\n  }\n\n  if (isRegExp(pattern)) {\n    return pattern.test(value);\n  }\n  if (isString(pattern)) {\n    return requireExactStringMatch ? value === pattern : value.includes(pattern);\n  }\n\n  return false;\n}\n\n/**\n * Test the given string against an array of strings and regexes. By default, string matching is done on a\n * substring-inclusion basis rather than a strict equality basis\n *\n * @param testString The string to test\n * @param patterns The patterns against which to test the string\n * @param requireExactStringMatch If true, `testString` must match one of the given string patterns exactly in order to\n * count. If false, `testString` will match a string pattern if it contains that pattern.\n * @returns\n */\nfunction stringMatchesSomePattern(\n  testString,\n  patterns = [],\n  requireExactStringMatch = false,\n) {\n  return patterns.some(pattern => isMatchingPattern(testString, pattern, requireExactStringMatch));\n}\n\n/**\n * Given a string, escape characters which have meaning in the regex grammar, such that the result is safe to feed to\n * `new RegExp()`.\n *\n * Based on https://github.com/sindresorhus/escape-string-regexp. Vendored to a) reduce the size by skipping the runtime\n * type-checking, and b) ensure it gets down-compiled for old versions of Node (the published package only supports Node\n * 12+).\n *\n * @param regexString The string to escape\n * @returns An version of the string with all special regex characters escaped\n */\nfunction escapeStringForRegex(regexString) {\n  // escape the hyphen separately so we can also replace it with a unicode literal hyphen, to avoid the problems\n  // discussed in https://github.com/sindresorhus/escape-string-regexp/issues/20.\n  return regexString.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d');\n}\n\nexport { escapeStringForRegex, isMatchingPattern, safeJoin, snipLine, stringMatchesSomePattern, truncate };\n//# sourceMappingURL=string.js.map\n","import { isThenable } from './is.js';\n\n/* eslint-disable @typescript-eslint/explicit-function-return-type */\n\n/** SyncPromise internal states */\nvar States; (function (States) {\n  /** Pending */\n  const PENDING = 0; States[States[\"PENDING\"] = PENDING] = \"PENDING\";\n  /** Resolved / OK */\n  const RESOLVED = 1; States[States[\"RESOLVED\"] = RESOLVED] = \"RESOLVED\";\n  /** Rejected / Error */\n  const REJECTED = 2; States[States[\"REJECTED\"] = REJECTED] = \"REJECTED\";\n})(States || (States = {}));\n\n// Overloads so we can call resolvedSyncPromise without arguments and generic argument\n\n/**\n * Creates a resolved sync promise.\n *\n * @param value the value to resolve the promise with\n * @returns the resolved sync promise\n */\nfunction resolvedSyncPromise(value) {\n  return new SyncPromise(resolve => {\n    resolve(value);\n  });\n}\n\n/**\n * Creates a rejected sync promise.\n *\n * @param value the value to reject the promise with\n * @returns the rejected sync promise\n */\nfunction rejectedSyncPromise(reason) {\n  return new SyncPromise((_, reject) => {\n    reject(reason);\n  });\n}\n\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nclass SyncPromise {\n   __init() {this._state = States.PENDING;}\n   __init2() {this._handlers = [];}\n\n   constructor(\n    executor,\n  ) {SyncPromise.prototype.__init.call(this);SyncPromise.prototype.__init2.call(this);SyncPromise.prototype.__init3.call(this);SyncPromise.prototype.__init4.call(this);SyncPromise.prototype.__init5.call(this);SyncPromise.prototype.__init6.call(this);\n    try {\n      executor(this._resolve, this._reject);\n    } catch (e) {\n      this._reject(e);\n    }\n  }\n\n  /** JSDoc */\n   then(\n    onfulfilled,\n    onrejected,\n  ) {\n    return new SyncPromise((resolve, reject) => {\n      this._handlers.push([\n        false,\n        result => {\n          if (!onfulfilled) {\n            // TODO: ¯\\_(ツ)_/¯\n            // TODO: FIXME\n            resolve(result );\n          } else {\n            try {\n              resolve(onfulfilled(result));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n        reason => {\n          if (!onrejected) {\n            reject(reason);\n          } else {\n            try {\n              resolve(onrejected(reason));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n      ]);\n      this._executeHandlers();\n    });\n  }\n\n  /** JSDoc */\n   catch(\n    onrejected,\n  ) {\n    return this.then(val => val, onrejected);\n  }\n\n  /** JSDoc */\n   finally(onfinally) {\n    return new SyncPromise((resolve, reject) => {\n      let val;\n      let isRejected;\n\n      return this.then(\n        value => {\n          isRejected = false;\n          val = value;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n        reason => {\n          isRejected = true;\n          val = reason;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n      ).then(() => {\n        if (isRejected) {\n          reject(val);\n          return;\n        }\n\n        resolve(val );\n      });\n    });\n  }\n\n  /** JSDoc */\n    __init3() {this._resolve = (value) => {\n    this._setResult(States.RESOLVED, value);\n  };}\n\n  /** JSDoc */\n    __init4() {this._reject = (reason) => {\n    this._setResult(States.REJECTED, reason);\n  };}\n\n  /** JSDoc */\n    __init5() {this._setResult = (state, value) => {\n    if (this._state !== States.PENDING) {\n      return;\n    }\n\n    if (isThenable(value)) {\n      void (value ).then(this._resolve, this._reject);\n      return;\n    }\n\n    this._state = state;\n    this._value = value;\n\n    this._executeHandlers();\n  };}\n\n  /** JSDoc */\n    __init6() {this._executeHandlers = () => {\n    if (this._state === States.PENDING) {\n      return;\n    }\n\n    const cachedHandlers = this._handlers.slice();\n    this._handlers = [];\n\n    cachedHandlers.forEach(handler => {\n      if (handler[0]) {\n        return;\n      }\n\n      if (this._state === States.RESOLVED) {\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        handler[1](this._value );\n      }\n\n      if (this._state === States.REJECTED) {\n        handler[2](this._value);\n      }\n\n      handler[0] = true;\n    });\n  };}\n}\n\nexport { SyncPromise, rejectedSyncPromise, resolvedSyncPromise };\n//# sourceMappingURL=syncpromise.js.map\n","import { isNodeEnv, dynamicRequire } from './node.js';\nimport { getGlobalObject } from './worldwide.js';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject();\n\n/**\n * An object that can return the current timestamp in seconds since the UNIX epoch.\n */\n\n/**\n * A TimestampSource implementation for environments that do not support the Performance Web API natively.\n *\n * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier\n * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It\n * is more obvious to explain \"why does my span have negative duration\" than \"why my spans have zero duration\".\n */\nconst dateTimestampSource = {\n  nowSeconds: () => Date.now() / 1000,\n};\n\n/**\n * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}\n * for accessing a high-resolution monotonic clock.\n */\n\n/**\n * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not\n * support the API.\n *\n * Wrapping the native API works around differences in behavior from different browsers.\n */\nfunction getBrowserPerformance() {\n  const { performance } = WINDOW;\n  if (!performance || !performance.now) {\n    return undefined;\n  }\n\n  // Replace performance.timeOrigin with our own timeOrigin based on Date.now().\n  //\n  // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +\n  // performance.now() gives a date arbitrarily in the past.\n  //\n  // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is\n  // undefined.\n  //\n  // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to\n  // interact with data coming out of performance entries.\n  //\n  // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that\n  // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes\n  // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have\n  // observed skews that can be as long as days, weeks or months.\n  //\n  // See https://github.com/getsentry/sentry-javascript/issues/2590.\n  //\n  // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload\n  // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation\n  // transactions of long-lived web pages.\n  const timeOrigin = Date.now() - performance.now();\n\n  return {\n    now: () => performance.now(),\n    timeOrigin,\n  };\n}\n\n/**\n * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't\n * implement the API.\n */\nfunction getNodePerformance() {\n  try {\n    const perfHooks = dynamicRequire(module, 'perf_hooks') ;\n    return perfHooks.performance;\n  } catch (_) {\n    return undefined;\n  }\n}\n\n/**\n * The Performance API implementation for the current platform, if available.\n */\nconst platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();\n\nconst timestampSource =\n  platformPerformance === undefined\n    ? dateTimestampSource\n    : {\n        nowSeconds: () => (platformPerformance.timeOrigin + platformPerformance.now()) / 1000,\n      };\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\nconst dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the\n * availability of the Performance API.\n *\n * See `usingPerformanceAPI` to test whether the Performance API is used.\n *\n * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is\n * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The\n * skew can grow to arbitrary amounts like days, weeks or months.\n * See https://github.com/getsentry/sentry-javascript/issues/2590.\n */\nconst timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);\n\n// Re-exported with an old name for backwards-compatibility.\nconst timestampWithMs = timestampInSeconds;\n\n/**\n * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.\n */\nconst usingPerformanceAPI = platformPerformance !== undefined;\n\n/**\n * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.\n */\nlet _browserPerformanceTimeOriginMode;\n\n/**\n * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the\n * performance API is available.\n */\nconst browserPerformanceTimeOrigin = (() => {\n  // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or\n  // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin\n  // data as reliable if they are within a reasonable threshold of the current time.\n\n  const { performance } = WINDOW;\n  if (!performance || !performance.now) {\n    _browserPerformanceTimeOriginMode = 'none';\n    return undefined;\n  }\n\n  const threshold = 3600 * 1000;\n  const performanceNow = performance.now();\n  const dateNow = Date.now();\n\n  // if timeOrigin isn't available set delta to threshold so it isn't used\n  const timeOriginDelta = performance.timeOrigin\n    ? Math.abs(performance.timeOrigin + performanceNow - dateNow)\n    : threshold;\n  const timeOriginIsReliable = timeOriginDelta < threshold;\n\n  // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin\n  // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.\n  // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always\n  // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the\n  // Date API.\n  // eslint-disable-next-line deprecation/deprecation\n  const navigationStart = performance.timing && performance.timing.navigationStart;\n  const hasNavigationStart = typeof navigationStart === 'number';\n  // if navigationStart isn't available set delta to threshold so it isn't used\n  const navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;\n  const navigationStartIsReliable = navigationStartDelta < threshold;\n\n  if (timeOriginIsReliable || navigationStartIsReliable) {\n    // Use the more reliable time origin\n    if (timeOriginDelta <= navigationStartDelta) {\n      _browserPerformanceTimeOriginMode = 'timeOrigin';\n      return performance.timeOrigin;\n    } else {\n      _browserPerformanceTimeOriginMode = 'navigationStart';\n      return navigationStart;\n    }\n  }\n\n  // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.\n  _browserPerformanceTimeOriginMode = 'dateNow';\n  return dateNow;\n})();\n\nexport { _browserPerformanceTimeOriginMode, browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds, timestampWithMs, usingPerformanceAPI };\n//# sourceMappingURL=time.js.map\n","/** Internal global with common properties and Sentry extensions  */\n\n// The code below for 'isGlobalObj' and 'GLOBAL_OBJ' was copied from core-js before modification\n// https://github.com/zloirock/core-js/blob/1b944df55282cdc99c90db5f49eb0b6eda2cc0a3/packages/core-js/internals/global.js\n// core-js has the following licence:\n//\n// Copyright (c) 2014-2022 Denis Pushkarev\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/** Returns 'obj' if it's the global object, otherwise returns undefined */\nfunction isGlobalObj(obj) {\n  return obj && obj.Math == Math ? obj : undefined;\n}\n\n/** Get's the global object for the current JavaScript runtime */\nconst GLOBAL_OBJ =\n  (typeof globalThis == 'object' && isGlobalObj(globalThis)) ||\n  // eslint-disable-next-line no-restricted-globals\n  (typeof window == 'object' && isGlobalObj(window)) ||\n  (typeof self == 'object' && isGlobalObj(self)) ||\n  (typeof global == 'object' && isGlobalObj(global)) ||\n  (function () {\n    return this;\n  })() ||\n  {};\n\n/**\n * @deprecated Use GLOBAL_OBJ instead or WINDOW from @sentry/browser. This will be removed in v8\n */\nfunction getGlobalObject() {\n  return GLOBAL_OBJ ;\n}\n\n/**\n * Returns a global singleton contained in the global `__SENTRY__` object.\n *\n * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory\n * function and added to the `__SENTRY__` object.\n *\n * @param name name of the global singleton on __SENTRY__\n * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`\n * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `GLOBAL_OBJ`'s return value\n * @returns the singleton\n */\nfunction getGlobalSingleton(name, creator, obj) {\n  const gbl = (obj || GLOBAL_OBJ) ;\n  const __SENTRY__ = (gbl.__SENTRY__ = gbl.__SENTRY__ || {});\n  const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());\n  return singleton;\n}\n\nexport { GLOBAL_OBJ, getGlobalObject, getGlobalSingleton };\n//# sourceMappingURL=worldwide.js.map\n","var _global = (typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}); _global.SENTRY_RELEASE={id:\"2dff45e932baf496abad41f2e8c3f753623e29bb\"};\n      _global.SENTRY_RELEASES=_global.SENTRY_RELEASES || {};\n      _global.SENTRY_RELEASES[\"web-frontend@clio-ai\"]={id:\"2dff45e932baf496abad41f2e8c3f753623e29bb\"};\n      "],"names":["captureException","exception","captureContext","captureMessage","message","level","undefined","context","captureEvent","event","hint","configureScope","callback","addBreadcrumb","breadcrumb","setContext","name","setExtras","extras","setExtra","key","extra","setTags","tags","setTag","value","setUser","user","withScope","startTransaction","customSamplingContext","API_VERSION","DEFAULT_BREADCRUMBS","Hub","__init","this","_stack","constructor","client","scope","_version","prototype","call","getStackTop","bindClient","isOlderThan","version","setupIntegrations","pushScope","clone","getScope","getStack","push","getClient","popScope","length","pop","eventId","_lastEventId","event_id","syntheticException","Error","_withClient","originalException","type","lastEventId","beforeBreadcrumb","maxBreadcrumbs","getOptions","mergedBreadcrumb","timestamp","finalBreadcrumb","run","oldHub","makeMain","getIntegration","integration","_oO","__SENTRY_DEBUG__","warn","id","_callExtensionMethod","traceHeaders","captureSession","endSession","_sendSessionUpdate","layer","session","getSession","setSession","startSession","release","environment","userAgent","navigator","getUser","currentSession","status","shouldSendDefaultPii","options","Boolean","sendDefaultPii","method","args","sentry","getMainCarrier","__SENTRY__","extensions","apply","hub","registry","getHubFromCarrier","setHubOnCarrier","getCurrentHub","hasHubOnCarrier","activeDomain","domain","active","registryHubTopStack","_Oo","getHubFromActiveDomain","carrier","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_attachments","_user","_tags","_extra","_contexts","_sdkProcessingMetadata","static","newScope","_level","_span","_session","_transactionName","_fingerprint","_requestSession","addScopeListener","addEventProcessor","_notifyScopeListeners","getRequestSession","setRequestSession","requestSession","setFingerprint","fingerprint","setLevel","setTransactionName","setSpan","span","getSpan","getTransaction","transaction","update","updatedScope","Object","keys","contexts","clear","maxCrumbs","slice","getLastBreadcrumb","clearBreadcrumbs","addAttachment","attachment","getAttachments","clearAttachments","applyToEvent","trace","getTraceContext","transactionName","_applyFingerprint","breadcrumbs","sdkProcessingMetadata","_notifyEventProcessors","getGlobalEventProcessors","setSDKProcessingMetadata","newData","processors","index","resolve","reject","processor","result","log","then","final","forEach","concat","addGlobalEventProcessor","makeSession","startingTime","sid","init","started","duration","errors","ignoreDuration","toJSON","Date","toISOString","did","attrs","ip_address","ipAddress","user_agent","sessionToJSON","updateSession","email","username","closeSession","WINDOW","DEFAULT_MAX_STRING_LENGTH","htmlTreeAsString","elem","currentElem","MAX_TRAVERSE_HEIGHT","out","height","len","separator","sepLength","nextStr","keyAttrs","Array","isArray","maxStringLength","_htmlElementAsString","parentNode","reverse","join","el","className","classes","attr","i","tagName","toLowerCase","keyAttrPairs","filter","keyAttr","getAttribute","map","keyAttrPair","split","allowedAttrs","getLocationHref","document","location","href","oO","isBrowserBundle","__SENTRY_BROWSER_BUNDLE__","getSDKSource","objectToString","toString","isError","wat","isInstanceOf","isBuiltin","isErrorEvent","isDOMError","isDOMException","isString","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","isSyntheticEvent","isNaN","base","_e","CONSOLE_LEVELS","consoleSandbox","originalConsole","console","wrappedLevels","originalWrappedFunc","__sentry_original__","makeLogger","enabled","logger","enable","disable","uuid4","gbl","crypto","msCrypto","randomUUID","replace","getRandomByte","getRandomValues","Uint8Array","Math","random","c","getFirstException","values","getEventDescription","firstException","addExceptionTypeValue","addExceptionMechanism","newMechanism","currentMechanism","mechanism","handled","mergedData","data","checkOrSetAlreadyCaught","__sentry_captured__","err","arrayify","maybeArray","isNodeEnv","process","dynamicRequire","mod","request","require","fill","source","replacementFactory","original","wrapped","markFunctionWrapped","addNonEnumerableProperty","obj","defineProperty","writable","configurable","proto","getOriginalFunction","func","urlEncode","object","encodeURIComponent","convertToPlainObject","stack","getOwnProperties","newObj","target","serializeEventTarget","currentTarget","CustomEvent","detail","extractedProps","property","hasOwnProperty","extractExceptionKeysForMessage","maxLength","sort","includedKeys","serialized","dropUndefinedKeys","inputValue","_dropUndefinedKeys","Map","memoizationMap","memoVal","get","returnValue","set","item","truncate","str","max","safeJoin","input","delimiter","output","String","e","stringMatchesSomePattern","testString","patterns","requireExactStringMatch","some","pattern","test","includes","isMatchingPattern","States","resolvedSyncPromise","SyncPromise","rejectedSyncPromise","reason","_","_state","PENDING","__init2","_handlers","executor","__init3","__init4","__init5","__init6","_resolve","_reject","onfulfilled","onrejected","_executeHandlers","catch","val","finally","onfinally","isRejected","_setResult","RESOLVED","REJECTED","state","_value","cachedHandlers","handler","dateTimestampSource","nowSeconds","now","platformPerformance","module","performance","getNodePerformance","timeOrigin","getBrowserPerformance","timestampSource","dateTimestampInSeconds","bind","timestampInSeconds","_browserPerformanceTimeOriginMode","browserPerformanceTimeOrigin","threshold","performanceNow","dateNow","timeOriginDelta","abs","timeOriginIsReliable","navigationStart","timing","navigationStartDelta","isGlobalObj","GLOBAL_OBJ","globalThis","window","self","g","getGlobalObject","getGlobalSingleton","creator","_global","SENTRY_RELEASE","SENTRY_RELEASES"],"sourceRoot":""}