{"version":3,"file":"js/487-7be8523c1a5295f66722.js","mappings":"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","sources":["webpack://nobi/./node_modules/@sentry/core/esm/constants.js","webpack://nobi/./node_modules/@sentry/core/esm/eventProcessors.js","webpack://nobi/./node_modules/@sentry/core/esm/exports.js","webpack://nobi/./node_modules/@sentry/core/esm/hub.js","webpack://nobi/./node_modules/@sentry/core/esm/scope.js","webpack://nobi/./node_modules/@sentry/core/esm/session.js","webpack://nobi/./node_modules/@sentry/utils/esm/browser.js","webpack://nobi/./node_modules/@sentry/utils/esm/env.js","webpack://nobi/./node_modules/@sentry/utils/esm/is.js","webpack://nobi/./node_modules/@sentry/utils/esm/logger.js","webpack://nobi/./node_modules/@sentry/utils/esm/misc.js","webpack://nobi/./node_modules/@sentry/utils/esm/node.js","webpack://nobi/./node_modules/@sentry/utils/esm/object.js","webpack://nobi/./node_modules/@sentry/utils/esm/string.js","webpack://nobi/./node_modules/@sentry/utils/esm/syncpromise.js","webpack://nobi/./node_modules/@sentry/utils/esm/time.js","webpack://nobi/./node_modules/@sentry/utils/esm/worldwide.js"],"sourcesContent":["const DEFAULT_ENVIRONMENT = 'production';\n\nexport { DEFAULT_ENVIRONMENT };\n//# sourceMappingURL=constants.js.map\n","import { getGlobalSingleton, SyncPromise, logger, isThenable } from '@sentry/utils';\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\n/**\n * Process an array of event processors, returning the processed event (or `null` if the event was dropped).\n */\nfunction 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 => notifyEventProcessors(processors, final, hint, index + 1).then(resolve))\n          .then(null, reject);\n      } else {\n        void notifyEventProcessors(processors, result, hint, index + 1)\n          .then(resolve)\n          .then(null, reject);\n      }\n    }\n  });\n}\n\nexport { addGlobalEventProcessor, getGlobalEventProcessors, notifyEventProcessors };\n//# sourceMappingURL=eventProcessors.js.map\n","import { logger, uuid4 } from '@sentry/utils';\nimport { 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\n/**\n * Create a cron monitor check in and send it to Sentry.\n *\n * @param checkIn An object that describes a check in.\n * @param upsertMonitorConfig An optional object that describes a monitor config. Use this if you want\n * to create a monitor automatically when sending a check in.\n */\nfunction captureCheckIn(checkIn, upsertMonitorConfig) {\n  const hub = getCurrentHub();\n  const scope = hub.getScope();\n  const client = hub.getClient();\n  if (!client) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot capture check-in. No client defined.');\n  } else if (!client.captureCheckIn) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot capture check-in. Client does not support sending check-ins.');\n  } else {\n    return client.captureCheckIn(checkIn, upsertMonitorConfig, scope);\n  }\n\n  return uuid4();\n}\n\n/**\n * Call `flush()` on the current client, if there is one. See {@link Client.flush}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue. Omitting this parameter will cause\n * the client to wait until all events are sent before resolving the promise.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nasync function flush(timeout) {\n  const client = getCurrentHub().getClient();\n  if (client) {\n    return client.flush(timeout);\n  }\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot flush events. No client defined.');\n  return Promise.resolve(false);\n}\n\n/**\n * Call `close()` on the current client, if there is one. See {@link Client.close}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue before shutting down. Omitting this\n * parameter will cause the client to wait until all events are sent before disabling itself.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nasync function close(timeout) {\n  const client = getCurrentHub().getClient();\n  if (client) {\n    return client.close(timeout);\n  }\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Cannot flush events and disable SDK. No client defined.');\n  return Promise.resolve(false);\n}\n\n/**\n * This is the getter for lastEventId.\n *\n * @returns The last event id of a captured event.\n */\nfunction lastEventId() {\n  return getCurrentHub().lastEventId();\n}\n\nexport { addBreadcrumb, captureCheckIn, captureEvent, captureException, captureMessage, close, configureScope, flush, lastEventId, setContext, setExtra, setExtras, setTag, setTags, setUser, startTransaction, withScope };\n//# sourceMappingURL=exports.js.map\n","import { uuid4, dateTimestampInSeconds, consoleSandbox, logger, GLOBAL_OBJ, getGlobalSingleton } from '@sentry/utils';\nimport { DEFAULT_ENVIRONMENT } from './constants.js';\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 * @inheritDoc\n */\nclass Hub  {\n  /** Is a {@link Layer}[] containing the client and scope */\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;\n    this._stack = [{ 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   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 (!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    if (client.emit) {\n      client.emit('beforeAddBreadcrumb', finalBreadcrumb, hint);\n    }\n\n    scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setUser(user) {\n    this.getScope().setUser(user);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTags(tags) {\n    this.getScope().setTags(tags);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setExtras(extras) {\n    this.getScope().setExtras(extras);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTag(key, value) {\n    this.getScope().setTag(key, value);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setExtra(key, extra) {\n    this.getScope().setExtra(key, extra);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n   setContext(name, context) {\n    this.getScope().setContext(name, context);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   configureScope(callback) {\n    const { scope, client } = this.getStackTop();\n    if (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    const result = this._callExtensionMethod('startTransaction', context, customSamplingContext);\n\n    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && !result) {\n      const client = this.getClient();\n      if (!client) {\n        // eslint-disable-next-line no-console\n        console.warn(\n          \"Tracing extension 'startTransaction' is missing. You should 'init' the SDK before calling 'startTransaction'\",\n        );\n      } else {\n        // eslint-disable-next-line no-console\n        console.warn(`Tracing extension 'startTransaction' has not been added. Call 'addTracingExtensions' before calling 'init':\nSentry.addTracingExtensions();\nSentry.init({...});\n`);\n      }\n    }\n\n    return result;\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.scope;\n    const session = 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    scope.setSession();\n  }\n\n  /**\n   * @inheritDoc\n   */\n   startSession(context) {\n    const { scope, client } = this.getStackTop();\n    const { release, environment = DEFAULT_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      user: scope.getUser(),\n      ...(userAgent && { userAgent }),\n      ...context,\n    });\n\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    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\n    const session = scope.getSession();\n    if (session && client && client.captureSession) {\n      client.captureSession(session);\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-expect-error 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 (registry.__SENTRY__ && registry.__SENTRY__.acs) {\n    const hub = registry.__SENTRY__.acs.getCurrentHub();\n\n    if (hub) {\n      return hub;\n    }\n  }\n\n  // Return hub that lives on a global object\n  return getGlobalHub(registry);\n}\n\nfunction getGlobalHub(registry = getMainCarrier()) {\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  // Return hub that lives on a global object\n  return getHubFromCarrier(registry);\n}\n\n/**\n * @private Private API with no semver guarantees!\n *\n * If the carrier does not contain a hub, a new hub is created with the global hub client and scope.\n */\nfunction ensureHubOnCarrier(carrier, parent = getGlobalHub()) {\n  // If there's no hub on current domain, or it's an old API, assign a new one\n  if (!hasHubOnCarrier(carrier) || getHubFromCarrier(carrier).isOlderThan(API_VERSION)) {\n    const globalHubTopStack = parent.getStackTop();\n    setHubOnCarrier(carrier, new Hub(globalHubTopStack.client, Scope.clone(globalHubTopStack.scope)));\n  }\n}\n\n/**\n * @private Private API with no semver guarantees!\n *\n * Sets the global async context strategy\n */\nfunction setAsyncContextStrategy(strategy) {\n  // Get main carrier (global for every environment)\n  const registry = getMainCarrier();\n  registry.__SENTRY__ = registry.__SENTRY__ || {};\n  registry.__SENTRY__.acs = strategy;\n}\n\n/**\n * Runs the supplied callback in its own async context. Async Context strategies are defined per SDK.\n *\n * @param callback The callback to run in its own async context\n * @param options Options to pass to the async context strategy\n * @returns The result of the callback\n */\nfunction runWithAsyncContext(callback, options = {}) {\n  const registry = getMainCarrier();\n\n  if (registry.__SENTRY__ && registry.__SENTRY__.acs) {\n    return registry.__SENTRY__.acs.runWithAsyncContext(callback, options);\n  }\n\n  // if there was no strategy, fallback to just calling the callback\n  return callback();\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, ensureHubOnCarrier, getCurrentHub, getHubFromCarrier, getMainCarrier, makeMain, runWithAsyncContext, setAsyncContextStrategy, setHubOnCarrier };\n//# sourceMappingURL=hub.js.map\n","import { isPlainObject, dateTimestampInSeconds, arrayify, uuid4 } from '@sentry/utils';\nimport { notifyEventProcessors, getGlobalEventProcessors } from './eventProcessors.js';\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  /** Propagation Context for distributed tracing */\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    this._propagationContext = generatePropagationContext();\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      newScope._propagationContext = { ...scope._propagationContext };\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      if (captureContext._propagationContext) {\n        this._propagationContext = captureContext._propagationContext;\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      if (captureContext.propagationContext) {\n        this._propagationContext = captureContext.propagationContext;\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    this._propagationContext = generatePropagationContext();\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\n    const breadcrumbs = this._breadcrumbs;\n    breadcrumbs.push(mergedBreadcrumb);\n    this._breadcrumbs = breadcrumbs.length > maxCrumbs ? breadcrumbs.slice(-maxCrumbs) : breadcrumbs;\n\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(\n    event,\n    hint = {},\n    additionalEventProcessors,\n  ) {\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 transaction = this._span.transaction;\n      if (transaction) {\n        event.sdkProcessingMetadata = {\n          dynamicSamplingContext: transaction.getDynamicSamplingContext(),\n          ...event.sdkProcessingMetadata,\n        };\n        const transactionName = transaction.name;\n        if (transactionName) {\n          event.tags = { transaction: transactionName, ...event.tags };\n        }\n      }\n    }\n\n    this._applyFingerprint(event);\n\n    const scopeBreadcrumbs = this._getBreadcrumbs();\n    const breadcrumbs = [...(event.breadcrumbs || []), ...scopeBreadcrumbs];\n    event.breadcrumbs = breadcrumbs.length > 0 ? breadcrumbs : undefined;\n\n    event.sdkProcessingMetadata = {\n      ...event.sdkProcessingMetadata,\n      ...this._sdkProcessingMetadata,\n      propagationContext: this._propagationContext,\n    };\n\n    // TODO (v8): Update this order to be: Global > Client > Scope\n    return notifyEventProcessors(\n      [...(additionalEventProcessors || []), ...getGlobalEventProcessors(), ...this._eventProcessors],\n      event,\n      hint,\n    );\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   * @inheritDoc\n   */\n   setPropagationContext(context) {\n    this._propagationContext = context;\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getPropagationContext() {\n    return this._propagationContext;\n  }\n\n  /**\n   * Get the breadcrumbs for this scope.\n   */\n   _getBreadcrumbs() {\n    return this._breadcrumbs;\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\nfunction generatePropagationContext() {\n  return {\n    traceId: uuid4(),\n    spanId: uuid4().substring(16),\n  };\n}\n\nexport { Scope };\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-expect-error \"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\n/**\n * Checks whether given value's type is a Vue ViewModel.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isVueViewModel(wat) {\n  // Not using Object.prototype.toString because in Vue 3 it would read the instance's Symbol(Symbol.toStringTag) property.\n  return !!(typeof wat === 'object' && wat !== null && ((wat ).__isVue || (wat )._isVue));\n}\n\nexport { isDOMError, isDOMException, isElement, isError, isErrorEvent, isEvent, isInstanceOf, isNaN, isPlainObject, isPrimitive, isRegExp, isString, isSyntheticEvent, isThenable, isVueViewModel };\n//# sourceMappingURL=is.js.map\n","import { 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/** This may be mutated by the console instrumentation. */\nconst originalConsoleMethods\n\n = {};\n\n/** JSDoc */\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 console = GLOBAL_OBJ.console ;\n  const wrappedFuncs = {};\n\n  const wrappedLevels = Object.keys(originalConsoleMethods) ;\n\n  // Restore all wrapped console methods\n  wrappedLevels.forEach(level => {\n    const originalConsoleMethod = originalConsoleMethods[level] ;\n    wrappedFuncs[level] = console[level] ;\n    console[level] = originalConsoleMethod;\n  });\n\n  try {\n    return callback();\n  } finally {\n    // Revert restoration to wrapped state\n    wrappedLevels.forEach(level => {\n      console[level] = wrappedFuncs[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\nconst logger = makeLogger();\n\nexport { CONSOLE_LEVELS, consoleSandbox, logger, originalConsoleMethods };\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  let getRandomByte = () => Math.random() * 16;\n  try {\n    if (crypto && crypto.randomUUID) {\n      return crypto.randomUUID().replace(/-/g, '');\n    }\n    if (crypto && crypto.getRandomValues) {\n      getRandomByte = () => crypto.getRandomValues(new Uint8Array(1))[0];\n    }\n  } catch (_) {\n    // some runtimes can crash invoking crypto\n    // https://github.com/getsentry/sentry-javascript/issues/8935\n  }\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 - 1, 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 { logger } from './logger.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    markFunctionWrapped(wrapped, original);\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  try {\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  } catch (o_O) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Failed to add non-enumerable property \"${name}\" to object`, obj);\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  try {\n    const proto = original.prototype || {};\n    wrapped.prototype = original.prototype = proto;\n    addNonEnumerableProperty(wrapped, '__sentry_original__', original);\n  } catch (o_O) {} // eslint-disable-line no-empty\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 { isVueViewModel, 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      // This is a hack to fix a Vue3-specific bug that causes an infinite loop of\n      // console warnings. This happens when a Vue template is rendered with\n      // an undeclared variable, which we try to stringify, ultimately causing\n      // Vue to issue another warning which repeats indefinitely.\n      // see: https://github.com/getsentry/sentry-javascript/pull/8981\n      if (isVueViewModel(value)) {\n        output.push('[VueViewModel]');\n      } else {\n        output.push(String(value));\n      }\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\nexport { 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\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);\n    this._state = States.PENDING;\n    this._handlers = [];\n\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    __init() {this._resolve = (value) => {\n    this._setResult(States.RESOLVED, value);\n  };}\n\n  /** JSDoc */\n    __init2() {this._reject = (reason) => {\n    this._setResult(States.REJECTED, reason);\n  };}\n\n  /** JSDoc */\n    __init3() {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    __init4() {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/**\n * Re-exported with an old name for backwards-compatibility.\n * TODO (v8): Remove this\n *\n * @deprecated Use `timestampInSeconds` instead.\n */\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"],"names":["DEFAULT_ENVIRONMENT","getGlobalEventProcessors","addGlobalEventProcessor","callback","push","notifyEventProcessors","processors","event","hint","index","resolve","reject","processor","result","__SENTRY_DEBUG__","id","log","then","final","captureException","exception","captureContext","withScope","API_VERSION","DEFAULT_BREADCRUMBS","Hub","constructor","client","scope","_version","this","_stack","bindClient","isOlderThan","version","getStackTop","setupIntegrations","pushScope","clone","getScope","getStack","getClient","popScope","length","pop","eventId","_lastEventId","event_id","syntheticException","Error","_withClient","originalException","captureMessage","message","level","captureEvent","type","lastEventId","addBreadcrumb","breadcrumb","beforeBreadcrumb","maxBreadcrumbs","getOptions","mergedBreadcrumb","timestamp","finalBreadcrumb","emit","setUser","user","setTags","tags","setExtras","extras","setTag","key","value","setExtra","extra","setContext","name","context","configureScope","run","oldHub","makeMain","getIntegration","integration","_oO","warn","startTransaction","customSamplingContext","_callExtensionMethod","console","traceHeaders","captureSession","endSession","_sendSessionUpdate","session","getSession","setSession","startSession","release","environment","userAgent","navigator","getUser","currentSession","status","shouldSendDefaultPii","options","Boolean","sendDefaultPii","method","args","sentry","getMainCarrier","__SENTRY__","extensions","apply","hub","undefined","registry","getHubFromCarrier","setHubOnCarrier","getCurrentHub","acs","getGlobalHub","hasHubOnCarrier","carrier","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_attachments","_user","_tags","_extra","_contexts","_sdkProcessingMetadata","_propagationContext","generatePropagationContext","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","propagationContext","clear","maxCrumbs","breadcrumbs","slice","getLastBreadcrumb","clearBreadcrumbs","addAttachment","attachment","getAttachments","clearAttachments","applyToEvent","additionalEventProcessors","trace","getTraceContext","sdkProcessingMetadata","dynamicSamplingContext","getDynamicSamplingContext","transactionName","_applyFingerprint","scopeBreadcrumbs","_getBreadcrumbs","setSDKProcessingMetadata","newData","setPropagationContext","getPropagationContext","forEach","concat","traceId","spanId","substring","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","prototype","toString","isError","wat","call","isInstanceOf","isBuiltin","isErrorEvent","isDOMError","isDOMException","isString","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","isSyntheticEvent","isNaN","base","_e","isVueViewModel","__isVue","_isVue","CONSOLE_LEVELS","originalConsoleMethods","consoleSandbox","wrappedFuncs","wrappedLevels","originalConsoleMethod","logger","enabled","enable","disable","makeLogger","uuid4","gbl","crypto","msCrypto","getRandomByte","Math","random","randomUUID","replace","getRandomValues","Uint8Array","_","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","o_O","proto","getOriginalFunction","func","__sentry_original__","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","executor","__init","__init2","__init3","__init4","_state","PENDING","_handlers","_resolve","_reject","onfulfilled","onrejected","_executeHandlers","val","onfinally","isRejected","_setResult","RESOLVED","REJECTED","state","_value","cachedHandlers","handler","dateTimestampSource","nowSeconds","now","platformPerformance","module","performance","getNodePerformance","timeOrigin","getBrowserPerformance","timestampSource","dateTimestampInSeconds","bind","timestampInSeconds","_browserPerformanceTimeOriginMode","threshold","performanceNow","dateNow","timeOriginDelta","abs","timeOriginIsReliable","navigationStart","timing","navigationStartDelta","isGlobalObj","GLOBAL_OBJ","globalThis","window","self","g","getGlobalObject","getGlobalSingleton","creator"],"sourceRoot":""}