{"version":3,"file":"js/94-f1b2555a1c1070d7f352.js","mappings":"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","sources":["webpack://app/./node_modules/@sentry/core/esm/hub.js","webpack://app/./node_modules/@sentry/core/esm/scope.js","webpack://app/./node_modules/@sentry/core/esm/session.js","webpack://app/./node_modules/@sentry/core/esm/version.js","webpack://app/./node_modules/@sentry/core/esm/integrations/inboundfilters.js","webpack://app/./node_modules/@sentry/core/esm/integrations/functiontostring.js","webpack://app/./node_modules/@sentry/core/esm/integration.js","webpack://app/./node_modules/@sentry/utils/esm/error.js","webpack://app/./node_modules/@sentry/utils/esm/dsn.js","webpack://app/./node_modules/@sentry/utils/esm/normalize.js","webpack://app/./node_modules/@sentry/utils/esm/memo.js","webpack://app/./node_modules/@sentry/utils/esm/envelope.js","webpack://app/./node_modules/@sentry/core/esm/api.js","webpack://app/./node_modules/@sentry/core/esm/envelope.js","webpack://app/./node_modules/@sentry/core/esm/baseclient.js","webpack://app/./node_modules/@sentry/browser/esm/eventbuilder.js","webpack://app/./node_modules/@sentry/core/esm/exports.js","webpack://app/./node_modules/@sentry/browser/esm/helpers.js","webpack://app/./node_modules/@sentry/utils/esm/severity.js","webpack://app/./node_modules/@sentry/utils/esm/url.js","webpack://app/./node_modules/@sentry/browser/esm/integrations/breadcrumbs.js","webpack://app/./node_modules/@sentry/browser/esm/client.js","webpack://app/./node_modules/@sentry/utils/esm/clientreport.js","webpack://app/./node_modules/@sentry/browser/esm/stack-parsers.js","webpack://app/./node_modules/@sentry/browser/esm/integrations/trycatch.js","webpack://app/./node_modules/@sentry/browser/esm/integrations/globalhandlers.js","webpack://app/./node_modules/@sentry/browser/esm/integrations/linkederrors.js","webpack://app/./node_modules/@sentry/browser/esm/integrations/dedupe.js","webpack://app/./node_modules/@sentry/browser/esm/integrations/httpcontext.js","webpack://app/./node_modules/@sentry/utils/esm/promisebuffer.js","webpack://app/./node_modules/@sentry/utils/esm/ratelimit.js","webpack://app/./node_modules/@sentry/core/esm/transports/base.js","webpack://app/./node_modules/@sentry/browser/esm/transports/utils.js","webpack://app/./node_modules/@sentry/browser/esm/transports/fetch.js","webpack://app/./node_modules/@sentry/browser/esm/transports/xhr.js","webpack://app/./node_modules/@sentry/browser/esm/sdk.js","webpack://app/./node_modules/@sentry/core/esm/sdk.js","webpack://app/./node_modules/@sentry/react/esm/sdk.js","webpack://app/./node_modules/@sentry/tracing/esm/errors.js","webpack://app/./node_modules/@sentry/tracing/esm/hubextensions.js","webpack://app/./node_modules/@sentry/tracing/esm/idletransaction.js","webpack://app/./node_modules/@sentry/utils/esm/tracing.js","webpack://app/./node_modules/@sentry/utils/esm/baggage.js","webpack://app/./node_modules/@sentry/tracing/esm/browser/types.js","webpack://app/./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/bindReporter.js","webpack://app/./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/getNavigationEntry.js","webpack://app/./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/getActivationStart.js","webpack://app/./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/initMetric.js","webpack://app/./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/generateUniqueID.js","webpack://app/./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/observe.js","webpack://app/./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/onHidden.js","webpack://app/./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/getVisibilityWatcher.js","webpack://app/./node_modules/@sentry/tracing/esm/browser/web-vitals/getLCP.js","webpack://app/./node_modules/@sentry/tracing/esm/browser/metrics/utils.js","webpack://app/./node_modules/@sentry/tracing/esm/browser/metrics/index.js","webpack://app/./node_modules/@sentry/tracing/esm/browser/web-vitals/getCLS.js","webpack://app/./node_modules/@sentry/tracing/esm/browser/web-vitals/getFID.js","webpack://app/./node_modules/@sentry/tracing/esm/browser/request.js","webpack://app/./node_modules/@sentry/tracing/esm/browser/browsertracing.js","webpack://app/./node_modules/@sentry/tracing/esm/browser/router.js","webpack://app/./node_modules/@sentry/utils/esm/buildPolyfills/_optionalChain.js","webpack://app/./node_modules/@sentry/tracing/esm/browser/backgroundtab.js","webpack://app/./node_modules/@sentry/tracing/esm/index.js","webpack://app/./node_modules/@sentry/tracing/esm/span.js","webpack://app/./node_modules/@sentry/tracing/esm/transaction.js","webpack://app/./node_modules/@sentry/tracing/esm/utils.js","webpack://app/./node_modules/@sentry/utils/esm/browser.js","webpack://app/./node_modules/@sentry/utils/esm/buildPolyfills/_nullishCoalesce.js","webpack://app/./node_modules/@sentry/utils/esm/instrument.js","webpack://app/./node_modules/@sentry/utils/esm/is.js","webpack://app/./node_modules/@sentry/utils/esm/logger.js","webpack://app/./node_modules/@sentry/utils/esm/misc.js","webpack://app/./node_modules/@sentry/utils/esm/node.js","webpack://app/./node_modules/@sentry/utils/esm/env.js","webpack://app/./node_modules/@sentry/utils/esm/object.js","webpack://app/./node_modules/@sentry/utils/esm/stacktrace.js","webpack://app/./node_modules/@sentry/utils/esm/string.js","webpack://app/./node_modules/@sentry/utils/esm/supports.js","webpack://app/./node_modules/@sentry/utils/esm/syncpromise.js","webpack://app/./node_modules/@sentry/utils/esm/time.js","webpack://app/./node_modules/@sentry/utils/esm/worldwide.js"],"sourcesContent":["import { uuid4, dateTimestampInSeconds, consoleSandbox, logger, GLOBAL_OBJ, isNodeEnv, getGlobalSingleton } from '@sentry/utils';\nimport { Scope } from './scope.js';\nimport { closeSession, makeSession, updateSession } from './session.js';\n\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be increased when the global interface\n * changes and new methods are introduced.\n *\n * @hidden\n */\nconst API_VERSION = 4;\n\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nconst DEFAULT_BREADCRUMBS = 100;\n\n/**\n * A layer in the process stack.\n * @hidden\n */\n\n/**\n * @inheritDoc\n */\nclass Hub  {\n  /** Is a {@link Layer}[] containing the client and scope */\n    __init() {this._stack = [{}];}\n\n  /** Contains the last event id of a captured event.  */\n\n  /**\n   * Creates a new instance of the hub, will push one {@link Layer} into the\n   * internal stack on creation.\n   *\n   * @param client bound to the hub.\n   * @param scope bound to the hub.\n   * @param version number, higher number means higher priority.\n   */\n   constructor(client, scope = new Scope(),   _version = API_VERSION) {;this._version = _version;Hub.prototype.__init.call(this);\n    this.getStackTop().scope = scope;\n    if (client) {\n      this.bindClient(client);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   isOlderThan(version) {\n    return this._version < version;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   bindClient(client) {\n    const top = this.getStackTop();\n    top.client = client;\n    if (client && client.setupIntegrations) {\n      client.setupIntegrations();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   pushScope() {\n    // We want to clone the content of prev scope\n    const scope = Scope.clone(this.getScope());\n    this.getStack().push({\n      client: this.getClient(),\n      scope,\n    });\n    return scope;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   popScope() {\n    if (this.getStack().length <= 1) return false;\n    return !!this.getStack().pop();\n  }\n\n  /**\n   * @inheritDoc\n   */\n   withScope(callback) {\n    const scope = this.pushScope();\n    try {\n      callback(scope);\n    } finally {\n      this.popScope();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getClient() {\n    return this.getStackTop().client ;\n  }\n\n  /** Returns the scope of the top stack. */\n   getScope() {\n    return this.getStackTop().scope;\n  }\n\n  /** Returns the scope stack for domains or the process. */\n   getStack() {\n    return this._stack;\n  }\n\n  /** Returns the topmost scope layer in the order domain > local > process. */\n   getStackTop() {\n    return this._stack[this._stack.length - 1];\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n   captureException(exception, hint) {\n    const eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n    const syntheticException = new Error('Sentry syntheticException');\n    this._withClient((client, scope) => {\n      client.captureException(\n        exception,\n        {\n          originalException: exception,\n          syntheticException,\n          ...hint,\n          event_id: eventId,\n        },\n        scope,\n      );\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureMessage(\n    message,\n    // eslint-disable-next-line deprecation/deprecation\n    level,\n    hint,\n  ) {\n    const eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n    const syntheticException = new Error(message);\n    this._withClient((client, scope) => {\n      client.captureMessage(\n        message,\n        level,\n        {\n          originalException: message,\n          syntheticException,\n          ...hint,\n          event_id: eventId,\n        },\n        scope,\n      );\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureEvent(event, hint) {\n    const eventId = hint && hint.event_id ? hint.event_id : uuid4();\n    if (event.type !== 'transaction') {\n      this._lastEventId = eventId;\n    }\n\n    this._withClient((client, scope) => {\n      client.captureEvent(event, { ...hint, event_id: eventId }, scope);\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   lastEventId() {\n    return this._lastEventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   addBreadcrumb(breadcrumb, hint) {\n    const { scope, client } = this.getStackTop();\n\n    if (!scope || !client) return;\n\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } =\n      (client.getOptions && client.getOptions()) || {};\n\n    if (maxBreadcrumbs <= 0) return;\n\n    const timestamp = dateTimestampInSeconds();\n    const mergedBreadcrumb = { timestamp, ...breadcrumb };\n    const finalBreadcrumb = beforeBreadcrumb\n      ? (consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) )\n      : mergedBreadcrumb;\n\n    if (finalBreadcrumb === null) return;\n\n    scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setUser(user) {\n    const scope = this.getScope();\n    if (scope) scope.setUser(user);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTags(tags) {\n    const scope = this.getScope();\n    if (scope) scope.setTags(tags);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setExtras(extras) {\n    const scope = this.getScope();\n    if (scope) scope.setExtras(extras);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTag(key, value) {\n    const scope = this.getScope();\n    if (scope) scope.setTag(key, value);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setExtra(key, extra) {\n    const scope = this.getScope();\n    if (scope) scope.setExtra(key, extra);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n   setContext(name, context) {\n    const scope = this.getScope();\n    if (scope) scope.setContext(name, context);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   configureScope(callback) {\n    const { scope, client } = this.getStackTop();\n    if (scope && client) {\n      callback(scope);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   run(callback) {\n    const oldHub = makeMain(this);\n    try {\n      callback(this);\n    } finally {\n      makeMain(oldHub);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getIntegration(integration) {\n    const client = this.getClient();\n    if (!client) return null;\n    try {\n      return client.getIntegration(integration);\n    } catch (_oO) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);\n      return null;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   startTransaction(context, customSamplingContext) {\n    return this._callExtensionMethod('startTransaction', context, customSamplingContext);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   traceHeaders() {\n    return this._callExtensionMethod('traceHeaders');\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureSession(endSession = false) {\n    // both send the update and pull the session from the scope\n    if (endSession) {\n      return this.endSession();\n    }\n\n    // only send the update\n    this._sendSessionUpdate();\n  }\n\n  /**\n   * @inheritDoc\n   */\n   endSession() {\n    const layer = this.getStackTop();\n    const scope = layer && layer.scope;\n    const session = scope && scope.getSession();\n    if (session) {\n      closeSession(session);\n    }\n    this._sendSessionUpdate();\n\n    // the session is over; take it off of the scope\n    if (scope) {\n      scope.setSession();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   startSession(context) {\n    const { scope, client } = this.getStackTop();\n    const { release, environment } = (client && client.getOptions()) || {};\n\n    // Will fetch userAgent if called from browser sdk\n    const { userAgent } = GLOBAL_OBJ.navigator || {};\n\n    const session = makeSession({\n      release,\n      environment,\n      ...(scope && { user: scope.getUser() }),\n      ...(userAgent && { userAgent }),\n      ...context,\n    });\n\n    if (scope) {\n      // End existing session if there's one\n      const currentSession = scope.getSession && scope.getSession();\n      if (currentSession && currentSession.status === 'ok') {\n        updateSession(currentSession, { status: 'exited' });\n      }\n      this.endSession();\n\n      // Afterwards we set the new session on the scope\n      scope.setSession(session);\n    }\n\n    return session;\n  }\n\n  /**\n   * Returns if default PII should be sent to Sentry and propagated in ourgoing requests\n   * when Tracing is used.\n   */\n   shouldSendDefaultPii() {\n    const client = this.getClient();\n    const options = client && client.getOptions();\n    return Boolean(options && options.sendDefaultPii);\n  }\n\n  /**\n   * Sends the current Session on the scope\n   */\n   _sendSessionUpdate() {\n    const { scope, client } = this.getStackTop();\n    if (!scope) return;\n\n    const session = scope.getSession();\n    if (session) {\n      if (client && client.captureSession) {\n        client.captureSession(session);\n      }\n    }\n  }\n\n  /**\n   * Internal helper function to call a method on the top client if it exists.\n   *\n   * @param method The method to call on the client.\n   * @param args Arguments to pass to the client function.\n   */\n   _withClient(callback) {\n    const { scope, client } = this.getStackTop();\n    if (client) {\n      callback(client, scope);\n    }\n  }\n\n  /**\n   * Calls global extension method and binding current instance to the function call\n   */\n  // @ts-ignore Function lacks ending return statement and return type does not include 'undefined'. ts(2366)\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n   _callExtensionMethod(method, ...args) {\n    const carrier = getMainCarrier();\n    const sentry = carrier.__SENTRY__;\n    if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n      return sentry.extensions[method].apply(this, args);\n    }\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);\n  }\n}\n\n/**\n * Returns the global shim registry.\n *\n * FIXME: This function is problematic, because despite always returning a valid Carrier,\n * it has an optional `__SENTRY__` property, which then in turn requires us to always perform an unnecessary check\n * at the call-site. We always access the carrier through this function, so we can guarantee that `__SENTRY__` is there.\n **/\nfunction getMainCarrier() {\n  GLOBAL_OBJ.__SENTRY__ = GLOBAL_OBJ.__SENTRY__ || {\n    extensions: {},\n    hub: undefined,\n  };\n  return GLOBAL_OBJ;\n}\n\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n */\nfunction makeMain(hub) {\n  const registry = getMainCarrier();\n  const oldHub = getHubFromCarrier(registry);\n  setHubOnCarrier(registry, hub);\n  return oldHub;\n}\n\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n */\nfunction getCurrentHub() {\n  // Get main carrier (global for every environment)\n  const registry = getMainCarrier();\n\n  // If there's no hub, or its an old API, assign a new one\n  if (!hasHubOnCarrier(registry) || getHubFromCarrier(registry).isOlderThan(API_VERSION)) {\n    setHubOnCarrier(registry, new Hub());\n  }\n\n  // Prefer domains over global if they are there (applicable only to Node environment)\n  if (isNodeEnv()) {\n    return getHubFromActiveDomain(registry);\n  }\n  // Return hub that lives on a global object\n  return getHubFromCarrier(registry);\n}\n\n/**\n * Try to read the hub from an active domain, and fallback to the registry if one doesn't exist\n * @returns discovered hub\n */\nfunction getHubFromActiveDomain(registry) {\n  try {\n    const sentry = getMainCarrier().__SENTRY__;\n    const activeDomain = sentry && sentry.extensions && sentry.extensions.domain && sentry.extensions.domain.active;\n\n    // If there's no active domain, just return global hub\n    if (!activeDomain) {\n      return getHubFromCarrier(registry);\n    }\n\n    // If there's no hub on current domain, or it's an old API, assign a new one\n    if (!hasHubOnCarrier(activeDomain) || getHubFromCarrier(activeDomain).isOlderThan(API_VERSION)) {\n      const registryHubTopStack = getHubFromCarrier(registry).getStackTop();\n      setHubOnCarrier(activeDomain, new Hub(registryHubTopStack.client, Scope.clone(registryHubTopStack.scope)));\n    }\n\n    // Return hub that lives on a domain\n    return getHubFromCarrier(activeDomain);\n  } catch (_Oo) {\n    // Return hub that lives on a global object\n    return getHubFromCarrier(registry);\n  }\n}\n\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier) {\n  return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);\n}\n\n/**\n * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\nfunction getHubFromCarrier(carrier) {\n  return getGlobalSingleton('hub', () => new Hub(), carrier);\n}\n\n/**\n * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute\n * @param carrier object\n * @param hub Hub\n * @returns A boolean indicating success or failure\n */\nfunction setHubOnCarrier(carrier, hub) {\n  if (!carrier) return false;\n  const __SENTRY__ = (carrier.__SENTRY__ = carrier.__SENTRY__ || {});\n  __SENTRY__.hub = hub;\n  return true;\n}\n\nexport { API_VERSION, Hub, getCurrentHub, getHubFromCarrier, getMainCarrier, makeMain, setHubOnCarrier };\n//# sourceMappingURL=hub.js.map\n","import { isPlainObject, dateTimestampInSeconds, SyncPromise, logger, isThenable, arrayify, getGlobalSingleton } from '@sentry/utils';\nimport { updateSession } from './session.js';\n\n/**\n * Default value for maximum number of breadcrumbs added to an event.\n */\nconst DEFAULT_MAX_BREADCRUMBS = 100;\n\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nclass Scope  {\n  /** Flag if notifying is happening. */\n\n  /** Callback for client to receive scope changes. */\n\n  /** Callback list that will be called after {@link applyToEvent}. */\n\n  /** Array of breadcrumbs. */\n\n  /** User */\n\n  /** Tags */\n\n  /** Extra */\n\n  /** Contexts */\n\n  /** Attachments */\n\n  /**\n   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get\n   * sent to Sentry\n   */\n\n  /** Fingerprint */\n\n  /** Severity */\n  // eslint-disable-next-line deprecation/deprecation\n\n  /** Transaction Name */\n\n  /** Span */\n\n  /** Session */\n\n  /** Request Mode Session Status */\n\n   constructor() {\n    this._notifyingListeners = false;\n    this._scopeListeners = [];\n    this._eventProcessors = [];\n    this._breadcrumbs = [];\n    this._attachments = [];\n    this._user = {};\n    this._tags = {};\n    this._extra = {};\n    this._contexts = {};\n    this._sdkProcessingMetadata = {};\n  }\n\n  /**\n   * Inherit values from the parent scope.\n   * @param scope to clone.\n   */\n   static clone(scope) {\n    const newScope = new Scope();\n    if (scope) {\n      newScope._breadcrumbs = [...scope._breadcrumbs];\n      newScope._tags = { ...scope._tags };\n      newScope._extra = { ...scope._extra };\n      newScope._contexts = { ...scope._contexts };\n      newScope._user = scope._user;\n      newScope._level = scope._level;\n      newScope._span = scope._span;\n      newScope._session = scope._session;\n      newScope._transactionName = scope._transactionName;\n      newScope._fingerprint = scope._fingerprint;\n      newScope._eventProcessors = [...scope._eventProcessors];\n      newScope._requestSession = scope._requestSession;\n      newScope._attachments = [...scope._attachments];\n    }\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 = { ...this._contexts, [key]: context };\n    }\n\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setSpan(span) {\n    this._span = span;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getSpan() {\n    return this._span;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getTransaction() {\n    // Often, this span (if it exists at all) will be a transaction, but it's not guaranteed to be. Regardless, it will\n    // have a pointer to the currently-active transaction.\n    const span = this.getSpan();\n    return span && span.transaction;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setSession(session) {\n    if (!session) {\n      delete this._session;\n    } else {\n      this._session = session;\n    }\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getSession() {\n    return this._session;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   update(captureContext) {\n    if (!captureContext) {\n      return this;\n    }\n\n    if (typeof captureContext === 'function') {\n      const updatedScope = (captureContext )(this);\n      return updatedScope instanceof Scope ? updatedScope : this;\n    }\n\n    if (captureContext instanceof Scope) {\n      this._tags = { ...this._tags, ...captureContext._tags };\n      this._extra = { ...this._extra, ...captureContext._extra };\n      this._contexts = { ...this._contexts, ...captureContext._contexts };\n      if (captureContext._user && Object.keys(captureContext._user).length) {\n        this._user = captureContext._user;\n      }\n      if (captureContext._level) {\n        this._level = captureContext._level;\n      }\n      if (captureContext._fingerprint) {\n        this._fingerprint = captureContext._fingerprint;\n      }\n      if (captureContext._requestSession) {\n        this._requestSession = captureContext._requestSession;\n      }\n    } else if (isPlainObject(captureContext)) {\n      // eslint-disable-next-line no-param-reassign\n      captureContext = captureContext ;\n      this._tags = { ...this._tags, ...captureContext.tags };\n      this._extra = { ...this._extra, ...captureContext.extra };\n      this._contexts = { ...this._contexts, ...captureContext.contexts };\n      if (captureContext.user) {\n        this._user = captureContext.user;\n      }\n      if (captureContext.level) {\n        this._level = captureContext.level;\n      }\n      if (captureContext.fingerprint) {\n        this._fingerprint = captureContext.fingerprint;\n      }\n      if (captureContext.requestSession) {\n        this._requestSession = captureContext.requestSession;\n      }\n    }\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   clear() {\n    this._breadcrumbs = [];\n    this._tags = {};\n    this._extra = {};\n    this._user = {};\n    this._contexts = {};\n    this._level = undefined;\n    this._transactionName = undefined;\n    this._fingerprint = undefined;\n    this._requestSession = undefined;\n    this._span = undefined;\n    this._session = undefined;\n    this._notifyScopeListeners();\n    this._attachments = [];\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   addBreadcrumb(breadcrumb, maxBreadcrumbs) {\n    const maxCrumbs = typeof maxBreadcrumbs === 'number' ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS;\n\n    // No data has been changed, so don't notify scope listeners\n    if (maxCrumbs <= 0) {\n      return this;\n    }\n\n    const mergedBreadcrumb = {\n      timestamp: dateTimestampInSeconds(),\n      ...breadcrumb,\n    };\n    this._breadcrumbs = [...this._breadcrumbs, mergedBreadcrumb].slice(-maxCrumbs);\n    this._notifyScopeListeners();\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   clearBreadcrumbs() {\n    this._breadcrumbs = [];\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   addAttachment(attachment) {\n    this._attachments.push(attachment);\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getAttachments() {\n    return this._attachments;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   clearAttachments() {\n    this._attachments = [];\n    return this;\n  }\n\n  /**\n   * Applies data from the scope to the event and runs all event processors on it.\n   *\n   * @param event Event\n   * @param hint Object containing additional information about the original exception, for use by the event processors.\n   * @hidden\n   */\n   applyToEvent(event, hint = {}) {\n    if (this._extra && Object.keys(this._extra).length) {\n      event.extra = { ...this._extra, ...event.extra };\n    }\n    if (this._tags && Object.keys(this._tags).length) {\n      event.tags = { ...this._tags, ...event.tags };\n    }\n    if (this._user && Object.keys(this._user).length) {\n      event.user = { ...this._user, ...event.user };\n    }\n    if (this._contexts && Object.keys(this._contexts).length) {\n      event.contexts = { ...this._contexts, ...event.contexts };\n    }\n    if (this._level) {\n      event.level = this._level;\n    }\n    if (this._transactionName) {\n      event.transaction = this._transactionName;\n    }\n\n    // We want to set the trace context for normal events only if there isn't already\n    // a trace context on the event. There is a product feature in place where we link\n    // errors with transaction and it relies on that.\n    if (this._span) {\n      event.contexts = { trace: this._span.getTraceContext(), ...event.contexts };\n      const transactionName = this._span.transaction && this._span.transaction.name;\n      if (transactionName) {\n        event.tags = { transaction: transactionName, ...event.tags };\n      }\n    }\n\n    this._applyFingerprint(event);\n\n    event.breadcrumbs = [...(event.breadcrumbs || []), ...this._breadcrumbs];\n    event.breadcrumbs = event.breadcrumbs.length > 0 ? event.breadcrumbs : undefined;\n\n    event.sdkProcessingMetadata = { ...event.sdkProcessingMetadata, ...this._sdkProcessingMetadata };\n\n    return this._notifyEventProcessors([...getGlobalEventProcessors(), ...this._eventProcessors], event, hint);\n  }\n\n  /**\n   * Add data which will be accessible during event processing but won't get sent to Sentry\n   */\n   setSDKProcessingMetadata(newData) {\n    this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...newData };\n\n    return this;\n  }\n\n  /**\n   * This will be called after {@link applyToEvent} is finished.\n   */\n   _notifyEventProcessors(\n    processors,\n    event,\n    hint,\n    index = 0,\n  ) {\n    return new SyncPromise((resolve, reject) => {\n      const processor = processors[index];\n      if (event === null || typeof processor !== 'function') {\n        resolve(event);\n      } else {\n        const result = processor({ ...event }, hint) ;\n\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n          processor.id &&\n          result === null &&\n          logger.log(`Event processor \"${processor.id}\" dropped event`);\n\n        if (isThenable(result)) {\n          void result\n            .then(final => this._notifyEventProcessors(processors, final, hint, index + 1).then(resolve))\n            .then(null, reject);\n        } else {\n          void this._notifyEventProcessors(processors, result, hint, index + 1)\n            .then(resolve)\n            .then(null, reject);\n        }\n      }\n    });\n  }\n\n  /**\n   * This will be called on every set call.\n   */\n   _notifyScopeListeners() {\n    // We need this check for this._notifyingListeners to be able to work on scope during updates\n    // If this check is not here we'll produce endless recursion when something is done with the scope\n    // during the callback.\n    if (!this._notifyingListeners) {\n      this._notifyingListeners = true;\n      this._scopeListeners.forEach(callback => {\n        callback(this);\n      });\n      this._notifyingListeners = false;\n    }\n  }\n\n  /**\n   * Applies fingerprint from the scope to the event if there's one,\n   * uses message if there's one instead or get rid of empty fingerprint\n   */\n   _applyFingerprint(event) {\n    // Make sure it's an array first and we actually have something in place\n    event.fingerprint = event.fingerprint ? arrayify(event.fingerprint) : [];\n\n    // If we have something on the scope, then merge it with event\n    if (this._fingerprint) {\n      event.fingerprint = event.fingerprint.concat(this._fingerprint);\n    }\n\n    // If we have no data at all, remove empty array default\n    if (event.fingerprint && !event.fingerprint.length) {\n      delete event.fingerprint;\n    }\n  }\n}\n\n/**\n * Returns the global event processors.\n */\nfunction getGlobalEventProcessors() {\n  return getGlobalSingleton('globalEventProcessors', () => []);\n}\n\n/**\n * Add a EventProcessor to be kept globally.\n * @param callback EventProcessor to add\n */\nfunction addGlobalEventProcessor(callback) {\n  getGlobalEventProcessors().push(callback);\n}\n\nexport { Scope, addGlobalEventProcessor };\n//# sourceMappingURL=scope.js.map\n","import { timestampInSeconds, uuid4, dropUndefinedKeys } from '@sentry/utils';\n\n/**\n * Creates a new `Session` object by setting certain default parameters. If optional @param context\n * is passed, the passed properties are applied to the session object.\n *\n * @param context (optional) additional properties to be applied to the returned session object\n *\n * @returns a new `Session` object\n */\nfunction makeSession(context) {\n  // Both timestamp and started are in seconds since the UNIX epoch.\n  const startingTime = timestampInSeconds();\n\n  const session = {\n    sid: uuid4(),\n    init: true,\n    timestamp: startingTime,\n    started: startingTime,\n    duration: 0,\n    status: 'ok',\n    errors: 0,\n    ignoreDuration: false,\n    toJSON: () => sessionToJSON(session),\n  };\n\n  if (context) {\n    updateSession(session, context);\n  }\n\n  return session;\n}\n\n/**\n * Updates a session object with the properties passed in the context.\n *\n * Note that this function mutates the passed object and returns void.\n * (Had to do this instead of returning a new and updated session because closing and sending a session\n * makes an update to the session after it was passed to the sending logic.\n * @see BaseClient.captureSession )\n *\n * @param session the `Session` to update\n * @param context the `SessionContext` holding the properties that should be updated in @param session\n */\n// eslint-disable-next-line complexity\nfunction updateSession(session, context = {}) {\n  if (context.user) {\n    if (!session.ipAddress && context.user.ip_address) {\n      session.ipAddress = context.user.ip_address;\n    }\n\n    if (!session.did && !context.did) {\n      session.did = context.user.id || context.user.email || context.user.username;\n    }\n  }\n\n  session.timestamp = context.timestamp || timestampInSeconds();\n\n  if (context.ignoreDuration) {\n    session.ignoreDuration = context.ignoreDuration;\n  }\n  if (context.sid) {\n    // Good enough uuid validation. — Kamil\n    session.sid = context.sid.length === 32 ? context.sid : uuid4();\n  }\n  if (context.init !== undefined) {\n    session.init = context.init;\n  }\n  if (!session.did && context.did) {\n    session.did = `${context.did}`;\n  }\n  if (typeof context.started === 'number') {\n    session.started = context.started;\n  }\n  if (session.ignoreDuration) {\n    session.duration = undefined;\n  } else if (typeof context.duration === 'number') {\n    session.duration = context.duration;\n  } else {\n    const duration = session.timestamp - session.started;\n    session.duration = duration >= 0 ? duration : 0;\n  }\n  if (context.release) {\n    session.release = context.release;\n  }\n  if (context.environment) {\n    session.environment = context.environment;\n  }\n  if (!session.ipAddress && context.ipAddress) {\n    session.ipAddress = context.ipAddress;\n  }\n  if (!session.userAgent && context.userAgent) {\n    session.userAgent = context.userAgent;\n  }\n  if (typeof context.errors === 'number') {\n    session.errors = context.errors;\n  }\n  if (context.status) {\n    session.status = context.status;\n  }\n}\n\n/**\n * Closes a session by setting its status and updating the session object with it.\n * Internally calls `updateSession` to update the passed session object.\n *\n * Note that this function mutates the passed session (@see updateSession for explanation).\n *\n * @param session the `Session` object to be closed\n * @param status the `SessionStatus` with which the session was closed. If you don't pass a status,\n *               this function will keep the previously set status, unless it was `'ok'` in which case\n *               it is changed to `'exited'`.\n */\nfunction closeSession(session, status) {\n  let context = {};\n  if (status) {\n    context = { status };\n  } else if (session.status === 'ok') {\n    context = { status: 'exited' };\n  }\n\n  updateSession(session, context);\n}\n\n/**\n * Serializes a passed session object to a JSON object with a slightly different structure.\n * This is necessary because the Sentry backend requires a slightly different schema of a session\n * than the one the JS SDKs use internally.\n *\n * @param session the session to be converted\n *\n * @returns a JSON object of the passed session\n */\nfunction sessionToJSON(session) {\n  return dropUndefinedKeys({\n    sid: `${session.sid}`,\n    init: session.init,\n    // Make sure that sec is converted to ms for date constructor\n    started: new Date(session.started * 1000).toISOString(),\n    timestamp: new Date(session.timestamp * 1000).toISOString(),\n    status: session.status,\n    errors: session.errors,\n    did: typeof session.did === 'number' || typeof session.did === 'string' ? `${session.did}` : undefined,\n    duration: session.duration,\n    attrs: {\n      release: session.release,\n      environment: session.environment,\n      ip_address: session.ipAddress,\n      user_agent: session.userAgent,\n    },\n  });\n}\n\nexport { closeSession, makeSession, updateSession };\n//# sourceMappingURL=session.js.map\n","const SDK_VERSION = '7.17.4';\n\nexport { SDK_VERSION };\n//# sourceMappingURL=version.js.map\n","import { logger, getEventDescription, isMatchingPattern } from '@sentry/utils';\n\n// \"Script error.\" is hard coded into browsers for errors that it can't read.\n// this is the result of a script being pulled in from an external domain and CORS.\nconst DEFAULT_IGNORE_ERRORS = [/^Script error\\.?$/, /^Javascript error: Script error\\.? on line 0$/];\n\n/** Options for the InboundFilters integration */\n\n/** Inbound filters configurable by the user */\nclass InboundFilters  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'InboundFilters';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = InboundFilters.id;}\n\n   constructor(  _options = {}) {;this._options = _options;InboundFilters.prototype.__init.call(this);}\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce(addGlobalEventProcessor, getCurrentHub) {\n    const eventProcess = (event) => {\n      const hub = getCurrentHub();\n      if (hub) {\n        const self = hub.getIntegration(InboundFilters);\n        if (self) {\n          const client = hub.getClient();\n          const clientOptions = client ? client.getOptions() : {};\n          const options = _mergeOptions(self._options, clientOptions);\n          return _shouldDropEvent(event, options) ? null : event;\n        }\n      }\n      return event;\n    };\n\n    eventProcess.id = this.name;\n    addGlobalEventProcessor(eventProcess);\n  }\n} InboundFilters.__initStatic();\n\n/** JSDoc */\nfunction _mergeOptions(\n  internalOptions = {},\n  clientOptions = {},\n) {\n  return {\n    allowUrls: [...(internalOptions.allowUrls || []), ...(clientOptions.allowUrls || [])],\n    denyUrls: [...(internalOptions.denyUrls || []), ...(clientOptions.denyUrls || [])],\n    ignoreErrors: [\n      ...(internalOptions.ignoreErrors || []),\n      ...(clientOptions.ignoreErrors || []),\n      ...DEFAULT_IGNORE_ERRORS,\n    ],\n    ignoreInternal: internalOptions.ignoreInternal !== undefined ? internalOptions.ignoreInternal : true,\n  };\n}\n\n/** JSDoc */\nfunction _shouldDropEvent(event, options) {\n  if (options.ignoreInternal && _isSentryError(event)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(`Event dropped due to being internal Sentry Error.\\nEvent: ${getEventDescription(event)}`);\n    return true;\n  }\n  if (_isIgnoredError(event, options.ignoreErrors)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(\n        `Event dropped due to being matched by \\`ignoreErrors\\` option.\\nEvent: ${getEventDescription(event)}`,\n      );\n    return true;\n  }\n  if (_isDeniedUrl(event, options.denyUrls)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(\n        `Event dropped due to being matched by \\`denyUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n      );\n    return true;\n  }\n  if (!_isAllowedUrl(event, options.allowUrls)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(\n        `Event dropped due to not being matched by \\`allowUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n      );\n    return true;\n  }\n  return false;\n}\n\nfunction _isIgnoredError(event, ignoreErrors) {\n  if (!ignoreErrors || !ignoreErrors.length) {\n    return false;\n  }\n\n  return _getPossibleEventMessages(event).some(message =>\n    ignoreErrors.some(pattern => isMatchingPattern(message, pattern)),\n  );\n}\n\nfunction _isDeniedUrl(event, denyUrls) {\n  // TODO: Use Glob instead?\n  if (!denyUrls || !denyUrls.length) {\n    return false;\n  }\n  const url = _getEventFilterUrl(event);\n  return !url ? false : denyUrls.some(pattern => isMatchingPattern(url, pattern));\n}\n\nfunction _isAllowedUrl(event, allowUrls) {\n  // TODO: Use Glob instead?\n  if (!allowUrls || !allowUrls.length) {\n    return true;\n  }\n  const url = _getEventFilterUrl(event);\n  return !url ? true : allowUrls.some(pattern => isMatchingPattern(url, pattern));\n}\n\nfunction _getPossibleEventMessages(event) {\n  if (event.message) {\n    return [event.message];\n  }\n  if (event.exception) {\n    try {\n      const { type = '', value = '' } = (event.exception.values && event.exception.values[0]) || {};\n      return [`${value}`, `${type}: ${value}`];\n    } catch (oO) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(`Cannot extract message for event ${getEventDescription(event)}`);\n      return [];\n    }\n  }\n  return [];\n}\n\nfunction _isSentryError(event) {\n  try {\n    // @ts-ignore can't be a sentry error if undefined\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return event.exception.values[0].type === 'SentryError';\n  } catch (e) {\n    // ignore\n  }\n  return false;\n}\n\nfunction _getLastValidUrl(frames = []) {\n  for (let i = frames.length - 1; i >= 0; i--) {\n    const frame = frames[i];\n\n    if (frame && frame.filename !== '<anonymous>' && frame.filename !== '[native code]') {\n      return frame.filename || null;\n    }\n  }\n\n  return null;\n}\n\nfunction _getEventFilterUrl(event) {\n  try {\n    let frames;\n    try {\n      // @ts-ignore we only care about frames if the whole thing here is defined\n      frames = event.exception.values[0].stacktrace.frames;\n    } catch (e) {\n      // ignore\n    }\n    return frames ? _getLastValidUrl(frames) : null;\n  } catch (oO) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(`Cannot extract url for event ${getEventDescription(event)}`);\n    return null;\n  }\n}\n\nexport { InboundFilters, _mergeOptions, _shouldDropEvent };\n//# sourceMappingURL=inboundfilters.js.map\n","import { getOriginalFunction } from '@sentry/utils';\n\nlet originalFunctionToString;\n\n/** Patch toString calls to return proper name for wrapped functions */\nclass FunctionToString  {constructor() { FunctionToString.prototype.__init.call(this); }\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'FunctionToString';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = FunctionToString.id;}\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce() {\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    originalFunctionToString = Function.prototype.toString;\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    Function.prototype.toString = function ( ...args) {\n      const context = getOriginalFunction(this) || this;\n      return originalFunctionToString.apply(context, args);\n    };\n  }\n} FunctionToString.__initStatic();\n\nexport { FunctionToString };\n//# sourceMappingURL=functiontostring.js.map\n","import { arrayify, logger } from '@sentry/utils';\nimport { getCurrentHub } from './hub.js';\nimport { addGlobalEventProcessor } from './scope.js';\n\nconst installedIntegrations = [];\n\n/** Map of integrations assigned to a client */\n\n/**\n * Remove duplicates from the given array, preferring the last instance of any duplicate. Not guaranteed to\n * preseve the order of integrations in the array.\n *\n * @private\n */\nfunction filterDuplicates(integrations) {\n  const integrationsByName = {};\n\n  integrations.forEach(currentInstance => {\n    const { name } = currentInstance;\n\n    const existingInstance = integrationsByName[name];\n\n    // We want integrations later in the array to overwrite earlier ones of the same type, except that we never want a\n    // default instance to overwrite an existing user instance\n    if (existingInstance && !existingInstance.isDefaultInstance && currentInstance.isDefaultInstance) {\n      return;\n    }\n\n    integrationsByName[name] = currentInstance;\n  });\n\n  return Object.values(integrationsByName);\n}\n\n/** Gets integrations to install */\nfunction getIntegrationsToSetup(options) {\n  const defaultIntegrations = options.defaultIntegrations || [];\n  const userIntegrations = options.integrations;\n\n  // We flag default instances, so that later we can tell them apart from any user-created instances of the same class\n  defaultIntegrations.forEach(integration => {\n    integration.isDefaultInstance = true;\n  });\n\n  let integrations;\n\n  if (Array.isArray(userIntegrations)) {\n    integrations = [...defaultIntegrations, ...userIntegrations];\n  } else if (typeof userIntegrations === 'function') {\n    integrations = arrayify(userIntegrations(defaultIntegrations));\n  } else {\n    integrations = defaultIntegrations;\n  }\n\n  const finalIntegrations = filterDuplicates(integrations);\n\n  // The `Debug` integration prints copies of the `event` and `hint` which will be passed to `beforeSend`. It therefore\n  // has to run after all other integrations, so that the changes of all event processors will be reflected in the\n  // printed values. For lack of a more elegant way to guarantee that, we therefore locate it and, assuming it exists,\n  // pop it out of its current spot and shove it onto the end of the array.\n  const debugIndex = finalIntegrations.findIndex(integration => integration.name === 'Debug');\n  if (debugIndex !== -1) {\n    const [debugInstance] = finalIntegrations.splice(debugIndex, 1);\n    finalIntegrations.push(debugInstance);\n  }\n\n  return finalIntegrations;\n}\n\n/**\n * Given a list of integration instances this installs them all. When `withDefaults` is set to `true` then all default\n * integrations are added unless they were already provided before.\n * @param integrations array of integration instances\n * @param withDefault should enable default integrations\n */\nfunction setupIntegrations(integrations) {\n  const integrationIndex = {};\n\n  integrations.forEach(integration => {\n    integrationIndex[integration.name] = integration;\n\n    if (installedIntegrations.indexOf(integration.name) === -1) {\n      integration.setupOnce(addGlobalEventProcessor, getCurrentHub);\n      installedIntegrations.push(integration.name);\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Integration installed: ${integration.name}`);\n    }\n  });\n\n  return integrationIndex;\n}\n\nexport { getIntegrationsToSetup, installedIntegrations, setupIntegrations };\n//# sourceMappingURL=integration.js.map\n","/** An error emitted by Sentry SDKs and related utilities. */\nclass SentryError extends Error {\n  /** Display name of this error instance. */\n\n   constructor( message, logLevel = 'warn') {\n    super(message);this.message = message;;\n\n    this.name = new.target.prototype.constructor.name;\n    // This sets the prototype to be `Error`, not `SentryError`. It's unclear why we do this, but commenting this line\n    // out causes various (seemingly totally unrelated) playwright tests consistently time out. FYI, this makes\n    // instances of `SentryError` fail `obj instanceof SentryError` checks.\n    Object.setPrototypeOf(this, new.target.prototype);\n    this.logLevel = logLevel;\n  }\n}\n\nexport { SentryError };\n//# sourceMappingURL=error.js.map\n","import { SentryError } from './error.js';\n\n/** Regular expression used to parse a Dsn. */\nconst DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+)?)?@)([\\w.-]+)(?::(\\d+))?\\/(.+)/;\n\nfunction isValidProtocol(protocol) {\n  return protocol === 'http' || protocol === 'https';\n}\n\n/**\n * Renders the string representation of this Dsn.\n *\n * By default, this will render the public representation without the password\n * component. To get the deprecated private representation, set `withPassword`\n * to true.\n *\n * @param withPassword When set to true, the password will be included.\n */\nfunction dsnToString(dsn, withPassword = false) {\n  const { host, path, pass, port, projectId, protocol, publicKey } = dsn;\n  return (\n    `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ''}` +\n    `@${host}${port ? `:${port}` : ''}/${path ? `${path}/` : path}${projectId}`\n  );\n}\n\n/**\n * Parses a Dsn from a given string.\n *\n * @param str A Dsn as string\n * @returns Dsn as DsnComponents\n */\nfunction dsnFromString(str) {\n  const match = DSN_REGEX.exec(str);\n\n  if (!match) {\n    throw new SentryError(`Invalid Sentry Dsn: ${str}`);\n  }\n\n  const [protocol, publicKey, pass = '', host, port = '', lastPath] = match.slice(1);\n  let path = '';\n  let projectId = lastPath;\n\n  const split = projectId.split('/');\n  if (split.length > 1) {\n    path = split.slice(0, -1).join('/');\n    projectId = split.pop() ;\n  }\n\n  if (projectId) {\n    const projectMatch = projectId.match(/^\\d+/);\n    if (projectMatch) {\n      projectId = projectMatch[0];\n    }\n  }\n\n  return dsnFromComponents({ host, pass, path, projectId, port, protocol: protocol , publicKey });\n}\n\nfunction dsnFromComponents(components) {\n  return {\n    protocol: components.protocol,\n    publicKey: components.publicKey || '',\n    pass: components.pass || '',\n    host: components.host,\n    port: components.port || '',\n    path: components.path || '',\n    projectId: components.projectId,\n  };\n}\n\nfunction validateDsn(dsn) {\n  if (!(typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n    return;\n  }\n\n  const { port, projectId, protocol } = dsn;\n\n  const requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];\n  requiredComponents.forEach(component => {\n    if (!dsn[component]) {\n      throw new SentryError(`Invalid Sentry Dsn: ${component} missing`);\n    }\n  });\n\n  if (!projectId.match(/^\\d+$/)) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);\n  }\n\n  if (!isValidProtocol(protocol)) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);\n  }\n\n  if (port && isNaN(parseInt(port, 10))) {\n    throw new SentryError(`Invalid Sentry Dsn: Invalid port ${port}`);\n  }\n\n  return true;\n}\n\n/** The Sentry Dsn, identifying a Sentry instance and project. */\nfunction makeDsn(from) {\n  const components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);\n  validateDsn(components);\n  return components;\n}\n\nexport { dsnFromString, dsnToString, makeDsn };\n//# sourceMappingURL=dsn.js.map\n","import { isNaN, isSyntheticEvent } from './is.js';\nimport { memoBuilder } from './memo.js';\nimport { convertToPlainObject } from './object.js';\nimport { getFunctionName } from './stacktrace.js';\n\n/**\n * Recursively normalizes the given object.\n *\n * - Creates a copy to prevent original input mutation\n * - Skips non-enumerable properties\n * - When stringifying, calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format\n * - Translates known global objects/classes to a string representations\n * - Takes care of `Error` object serialization\n * - Optionally limits depth of final output\n * - Optionally limits number of properties/elements included in any single object/array\n *\n * @param input The object to be normalized.\n * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)\n * @param maxProperties The max number of elements or properties to be included in any single array or\n * object in the normallized output.\n * @returns A normalized version of the object, or `\"**non-serializable**\"` if any errors are thrown during normalization.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction normalize(input, depth = +Infinity, maxProperties = +Infinity) {\n  try {\n    // since we're at the outermost level, we don't provide a key\n    return visit('', input, depth, maxProperties);\n  } catch (err) {\n    return { ERROR: `**non-serializable** (${err})` };\n  }\n}\n\n/** JSDoc */\nfunction normalizeToSize(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  object,\n  // Default Node.js REPL depth\n  depth = 3,\n  // 100kB, as 200kB is max payload size, so half sounds reasonable\n  maxSize = 100 * 1024,\n) {\n  const normalized = normalize(object, depth);\n\n  if (jsonSize(normalized) > maxSize) {\n    return normalizeToSize(object, depth - 1, maxSize);\n  }\n\n  return normalized ;\n}\n\n/**\n * Visits a node to perform normalization on it\n *\n * @param key The key corresponding to the given node\n * @param value The node to be visited\n * @param depth Optional number indicating the maximum recursion depth\n * @param maxProperties Optional maximum number of properties/elements included in any single object/array\n * @param memo Optional Memo class handling decycling\n */\nfunction visit(\n  key,\n  value,\n  depth = +Infinity,\n  maxProperties = +Infinity,\n  memo = memoBuilder(),\n) {\n  const [memoize, unmemoize] = memo;\n\n  // Get the simple cases out of the way first\n  if (value === null || (['number', 'boolean', 'string'].includes(typeof value) && !isNaN(value))) {\n    return value ;\n  }\n\n  const stringified = stringifyValue(key, value);\n\n  // Anything we could potentially dig into more (objects or arrays) will have come back as `\"[object XXXX]\"`.\n  // Everything else will have already been serialized, so if we don't see that pattern, we're done.\n  if (!stringified.startsWith('[object ')) {\n    return stringified;\n  }\n\n  // From here on, we can assert that `value` is either an object or an array.\n\n  // Do not normalize objects that we know have already been normalized. As a general rule, the\n  // \"__sentry_skip_normalization__\" property should only be used sparingly and only should only be set on objects that\n  // have already been normalized.\n  if ((value )['__sentry_skip_normalization__']) {\n    return value ;\n  }\n\n  // We're also done if we've reached the max depth\n  if (depth === 0) {\n    // At this point we know `serialized` is a string of the form `\"[object XXXX]\"`. Clean it up so it's just `\"[XXXX]\"`.\n    return stringified.replace('object ', '');\n  }\n\n  // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.\n  if (memoize(value)) {\n    return '[Circular ~]';\n  }\n\n  // If the value has a `toJSON` method, we call it to extract more information\n  const valueWithToJSON = value ;\n  if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {\n    try {\n      const jsonValue = valueWithToJSON.toJSON();\n      // We need to normalize the return value of `.toJSON()` in case it has circular references\n      return visit('', jsonValue, depth - 1, maxProperties, memo);\n    } catch (err) {\n      // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)\n    }\n  }\n\n  // At this point we know we either have an object or an array, we haven't seen it before, and we're going to recurse\n  // because we haven't yet reached the max depth. Create an accumulator to hold the results of visiting each\n  // property/entry, and keep track of the number of items we add to it.\n  const normalized = (Array.isArray(value) ? [] : {}) ;\n  let numAdded = 0;\n\n  // Before we begin, convert`Error` and`Event` instances into plain objects, since some of each of their relevant\n  // properties are non-enumerable and otherwise would get missed.\n  const visitable = convertToPlainObject(value );\n\n  for (const visitKey in visitable) {\n    // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.\n    if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) {\n      continue;\n    }\n\n    if (numAdded >= maxProperties) {\n      normalized[visitKey] = '[MaxProperties ~]';\n      break;\n    }\n\n    // Recursively visit all the child nodes\n    const visitValue = visitable[visitKey];\n    normalized[visitKey] = visit(visitKey, visitValue, depth - 1, maxProperties, memo);\n\n    numAdded += 1;\n  }\n\n  // Once we've visited all the branches, remove the parent from memo storage\n  unmemoize(value);\n\n  // Return accumulated values\n  return normalized;\n}\n\n/**\n * Stringify the given value. Handles various known special values and types.\n *\n * Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn\n * the number 1231 into \"[Object Number]\", nor on `null`, as it will throw.\n *\n * @param value The value to stringify\n * @returns A stringified representation of the given value\n */\nfunction stringifyValue(\n  key,\n  // this type is a tiny bit of a cheat, since this function does handle NaN (which is technically a number), but for\n  // our internal use, it'll do\n  value,\n) {\n  try {\n    if (key === 'domain' && value && typeof value === 'object' && (value )._events) {\n      return '[Domain]';\n    }\n\n    if (key === 'domainEmitter') {\n      return '[DomainEmitter]';\n    }\n\n    // It's safe to use `global`, `window`, and `document` here in this manner, as we are asserting using `typeof` first\n    // which won't throw if they are not present.\n\n    if (typeof global !== 'undefined' && value === global) {\n      return '[Global]';\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    if (typeof window !== 'undefined' && value === window) {\n      return '[Window]';\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    if (typeof document !== 'undefined' && value === document) {\n      return '[Document]';\n    }\n\n    // React's SyntheticEvent thingy\n    if (isSyntheticEvent(value)) {\n      return '[SyntheticEvent]';\n    }\n\n    if (typeof value === 'number' && value !== value) {\n      return '[NaN]';\n    }\n\n    // this catches `undefined` (but not `null`, which is a primitive and can be serialized on its own)\n    if (value === void 0) {\n      return '[undefined]';\n    }\n\n    if (typeof value === 'function') {\n      return `[Function: ${getFunctionName(value)}]`;\n    }\n\n    if (typeof value === 'symbol') {\n      return `[${String(value)}]`;\n    }\n\n    // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion\n    if (typeof value === 'bigint') {\n      return `[BigInt: ${String(value)}]`;\n    }\n\n    // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting\n    // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as\n    // `\"[object Object]\"`. If we instead look at the constructor's name (which is the same as the name of the class),\n    // we can make sure that only plain objects come out that way.\n    return `[object ${(Object.getPrototypeOf(value) ).constructor.name}]`;\n  } catch (err) {\n    return `**non-serializable** (${err})`;\n  }\n}\n\n/** Calculates bytes size of input string */\nfunction utf8Length(value) {\n  // eslint-disable-next-line no-bitwise\n  return ~-encodeURI(value).split(/%..|./).length;\n}\n\n/** Calculates bytes size of input object */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction jsonSize(value) {\n  return utf8Length(JSON.stringify(value));\n}\n\nexport { normalize, normalizeToSize, visit as walk };\n//# sourceMappingURL=normalize.js.map\n","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n/**\n * Helper to decycle json objects\n */\nfunction memoBuilder() {\n  const hasWeakSet = typeof WeakSet === 'function';\n  const inner = hasWeakSet ? new WeakSet() : [];\n  function memoize(obj) {\n    if (hasWeakSet) {\n      if (inner.has(obj)) {\n        return true;\n      }\n      inner.add(obj);\n      return false;\n    }\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (let i = 0; i < inner.length; i++) {\n      const value = inner[i];\n      if (value === obj) {\n        return true;\n      }\n    }\n    inner.push(obj);\n    return false;\n  }\n\n  function unmemoize(obj) {\n    if (hasWeakSet) {\n      inner.delete(obj);\n    } else {\n      for (let i = 0; i < inner.length; i++) {\n        if (inner[i] === obj) {\n          inner.splice(i, 1);\n          break;\n        }\n      }\n    }\n  }\n  return [memoize, unmemoize];\n}\n\nexport { memoBuilder };\n//# sourceMappingURL=memo.js.map\n","import { normalize } from './normalize.js';\nimport { dropUndefinedKeys } from './object.js';\n\n/**\n * Creates an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nfunction createEnvelope(headers, items = []) {\n  return [headers, items] ;\n}\n\n/**\n * Add an item to an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nfunction addItemToEnvelope(envelope, newItem) {\n  const [headers, items] = envelope;\n  return [headers, [...items, newItem]] ;\n}\n\n/**\n * Convenience function to loop through the items and item types of an envelope.\n * (This function was mostly created because working with envelope types is painful at the moment)\n */\nfunction forEachEnvelopeItem(\n  envelope,\n  callback,\n) {\n  const envelopeItems = envelope[1];\n  envelopeItems.forEach((envelopeItem) => {\n    const envelopeItemType = envelopeItem[0].type;\n    callback(envelopeItem, envelopeItemType);\n  });\n}\n\nfunction encodeUTF8(input, textEncoder) {\n  const utf8 = textEncoder || new TextEncoder();\n  return utf8.encode(input);\n}\n\n/**\n * Serializes an envelope.\n */\nfunction serializeEnvelope(envelope, textEncoder) {\n  const [envHeaders, items] = envelope;\n\n  // Initially we construct our envelope as a string and only convert to binary chunks if we encounter binary data\n  let parts = JSON.stringify(envHeaders);\n\n  function append(next) {\n    if (typeof parts === 'string') {\n      parts = typeof next === 'string' ? parts + next : [encodeUTF8(parts, textEncoder), next];\n    } else {\n      parts.push(typeof next === 'string' ? encodeUTF8(next, textEncoder) : next);\n    }\n  }\n\n  for (const item of items) {\n    const [itemHeaders, payload] = item;\n\n    append(`\\n${JSON.stringify(itemHeaders)}\\n`);\n\n    if (typeof payload === 'string' || payload instanceof Uint8Array) {\n      append(payload);\n    } else {\n      let stringifiedPayload;\n      try {\n        stringifiedPayload = JSON.stringify(payload);\n      } catch (e) {\n        // In case, despite all our efforts to keep `payload` circular-dependency-free, `JSON.strinify()` still\n        // fails, we try again after normalizing it again with infinite normalization depth. This of course has a\n        // performance impact but in this case a performance hit is better than throwing.\n        stringifiedPayload = JSON.stringify(normalize(payload));\n      }\n      append(stringifiedPayload);\n    }\n  }\n\n  return typeof parts === 'string' ? parts : concatBuffers(parts);\n}\n\nfunction concatBuffers(buffers) {\n  const totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);\n\n  const merged = new Uint8Array(totalLength);\n  let offset = 0;\n  for (const buffer of buffers) {\n    merged.set(buffer, offset);\n    offset += buffer.length;\n  }\n\n  return merged;\n}\n\n/**\n * Creates attachment envelope items\n */\nfunction createAttachmentEnvelopeItem(\n  attachment,\n  textEncoder,\n) {\n  const buffer = typeof attachment.data === 'string' ? encodeUTF8(attachment.data, textEncoder) : attachment.data;\n\n  return [\n    dropUndefinedKeys({\n      type: 'attachment',\n      length: buffer.length,\n      filename: attachment.filename,\n      content_type: attachment.contentType,\n      attachment_type: attachment.attachmentType,\n    }),\n    buffer,\n  ];\n}\n\nconst ITEM_TYPE_TO_DATA_CATEGORY_MAP = {\n  session: 'session',\n  sessions: 'session',\n  attachment: 'attachment',\n  transaction: 'transaction',\n  event: 'error',\n  client_report: 'internal',\n  user_report: 'default',\n};\n\n/**\n * Maps the type of an envelope item to a data category.\n */\nfunction envelopeItemTypeToDataCategory(type) {\n  return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];\n}\n\nexport { addItemToEnvelope, createAttachmentEnvelopeItem, createEnvelope, envelopeItemTypeToDataCategory, forEachEnvelopeItem, serializeEnvelope };\n//# sourceMappingURL=envelope.js.map\n","import { urlEncode, makeDsn, dsnToString } from '@sentry/utils';\n\nconst SENTRY_API_VERSION = '7';\n\n/** Returns the prefix to construct Sentry ingestion API endpoints. */\nfunction getBaseApiEndpoint(dsn) {\n  const protocol = dsn.protocol ? `${dsn.protocol}:` : '';\n  const port = dsn.port ? `:${dsn.port}` : '';\n  return `${protocol}//${dsn.host}${port}${dsn.path ? `/${dsn.path}` : ''}/api/`;\n}\n\n/** Returns the ingest API endpoint for target. */\nfunction _getIngestEndpoint(dsn) {\n  return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/envelope/`;\n}\n\n/** Returns a URL-encoded string with auth config suitable for a query string. */\nfunction _encodedAuth(dsn, sdkInfo) {\n  return urlEncode({\n    // We send only the minimum set of required information. See\n    // https://github.com/getsentry/sentry-javascript/issues/2572.\n    sentry_key: dsn.publicKey,\n    sentry_version: SENTRY_API_VERSION,\n    ...(sdkInfo && { sentry_client: `${sdkInfo.name}/${sdkInfo.version}` }),\n  });\n}\n\n/**\n * Returns the envelope endpoint URL with auth in the query string.\n *\n * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.\n */\nfunction getEnvelopeEndpointWithUrlEncodedAuth(\n  dsn,\n  // TODO (v8): Remove `tunnelOrOptions` in favor of `options`, and use the substitute code below\n  // options: ClientOptions = {} as ClientOptions,\n  tunnelOrOptions = {} ,\n) {\n  // TODO (v8): Use this code instead\n  // const { tunnel, _metadata = {} } = options;\n  // return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, _metadata.sdk)}`;\n\n  const tunnel = typeof tunnelOrOptions === 'string' ? tunnelOrOptions : tunnelOrOptions.tunnel;\n  const sdkInfo =\n    typeof tunnelOrOptions === 'string' || !tunnelOrOptions._metadata ? undefined : tunnelOrOptions._metadata.sdk;\n\n  return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, sdkInfo)}`;\n}\n\n/** Returns the url to the report dialog endpoint. */\nfunction getReportDialogEndpoint(\n  dsnLike,\n  dialogOptions\n\n,\n) {\n  const dsn = makeDsn(dsnLike);\n  const endpoint = `${getBaseApiEndpoint(dsn)}embed/error-page/`;\n\n  let encodedOptions = `dsn=${dsnToString(dsn)}`;\n  for (const key in dialogOptions) {\n    if (key === 'dsn') {\n      continue;\n    }\n\n    if (key === 'user') {\n      const user = dialogOptions.user;\n      if (!user) {\n        continue;\n      }\n      if (user.name) {\n        encodedOptions += `&name=${encodeURIComponent(user.name)}`;\n      }\n      if (user.email) {\n        encodedOptions += `&email=${encodeURIComponent(user.email)}`;\n      }\n    } else {\n      encodedOptions += `&${encodeURIComponent(key)}=${encodeURIComponent(dialogOptions[key] )}`;\n    }\n  }\n\n  return `${endpoint}?${encodedOptions}`;\n}\n\nexport { getEnvelopeEndpointWithUrlEncodedAuth, getReportDialogEndpoint };\n//# sourceMappingURL=api.js.map\n","import { dsnToString, createEnvelope, dropUndefinedKeys } from '@sentry/utils';\n\n/** Extract sdk info from from the API metadata */\nfunction getSdkMetadataForEnvelopeHeader(metadata) {\n  if (!metadata || !metadata.sdk) {\n    return;\n  }\n  const { name, version } = metadata.sdk;\n  return { name, version };\n}\n\n/**\n * Apply SdkInfo (name, version, packages, integrations) to the corresponding event key.\n * Merge with existing data if any.\n **/\nfunction enhanceEventWithSdkInfo(event, sdkInfo) {\n  if (!sdkInfo) {\n    return event;\n  }\n  event.sdk = event.sdk || {};\n  event.sdk.name = event.sdk.name || sdkInfo.name;\n  event.sdk.version = event.sdk.version || sdkInfo.version;\n  event.sdk.integrations = [...(event.sdk.integrations || []), ...(sdkInfo.integrations || [])];\n  event.sdk.packages = [...(event.sdk.packages || []), ...(sdkInfo.packages || [])];\n  return event;\n}\n\n/** Creates an envelope from a Session */\nfunction createSessionEnvelope(\n  session,\n  dsn,\n  metadata,\n  tunnel,\n) {\n  const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);\n  const envelopeHeaders = {\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && { dsn: dsnToString(dsn) }),\n  };\n\n  const envelopeItem =\n    'aggregates' in session ? [{ type: 'sessions' }, session] : [{ type: 'session' }, session];\n\n  return createEnvelope(envelopeHeaders, [envelopeItem]);\n}\n\n/**\n * Create an Envelope from an event.\n */\nfunction createEventEnvelope(\n  event,\n  dsn,\n  metadata,\n  tunnel,\n) {\n  const sdkInfo = getSdkMetadataForEnvelopeHeader(metadata);\n  const eventType = event.type || 'event';\n\n  enhanceEventWithSdkInfo(event, metadata && metadata.sdk);\n\n  const envelopeHeaders = createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn);\n\n  // Prevent this data (which, if it exists, was used in earlier steps in the processing pipeline) from being sent to\n  // sentry. (Note: Our use of this property comes and goes with whatever we might be debugging, whatever hacks we may\n  // have temporarily added, etc. Even if we don't happen to be using it at some point in the future, let's not get rid\n  // of this `delete`, lest we miss putting it back in the next time the property is in use.)\n  delete event.sdkProcessingMetadata;\n\n  const eventItem = [{ type: eventType }, event];\n  return createEnvelope(envelopeHeaders, [eventItem]);\n}\n\nfunction createEventEnvelopeHeaders(\n  event,\n  sdkInfo,\n  tunnel,\n  dsn,\n) {\n  const dynamicSamplingContext = event.sdkProcessingMetadata && event.sdkProcessingMetadata.dynamicSamplingContext;\n\n  return {\n    event_id: event.event_id ,\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && { dsn: dsnToString(dsn) }),\n    ...(event.type === 'transaction' &&\n      dynamicSamplingContext && {\n        trace: dropUndefinedKeys({ ...dynamicSamplingContext }),\n      }),\n  };\n}\n\nexport { createEventEnvelope, createSessionEnvelope };\n//# sourceMappingURL=envelope.js.map\n","import { makeDsn, logger, checkOrSetAlreadyCaught, isPrimitive, resolvedSyncPromise, addItemToEnvelope, createAttachmentEnvelopeItem, SyncPromise, uuid4, dateTimestampInSeconds, normalize, truncate, rejectedSyncPromise, SentryError, isThenable, isPlainObject } from '@sentry/utils';\nimport { getEnvelopeEndpointWithUrlEncodedAuth } from './api.js';\nimport { createEventEnvelope, createSessionEnvelope } from './envelope.js';\nimport { setupIntegrations } from './integration.js';\nimport { Scope } from './scope.js';\nimport { updateSession } from './session.js';\n\nconst ALREADY_SEEN_ERROR = \"Not capturing exception because it's already been captured.\";\n\n/**\n * Base implementation for all JavaScript SDK clients.\n *\n * Call the constructor with the corresponding options\n * specific to the client subclass. To access these options later, use\n * {@link Client.getOptions}.\n *\n * If a Dsn is specified in the options, it will be parsed and stored. Use\n * {@link Client.getDsn} to retrieve the Dsn at any moment. In case the Dsn is\n * invalid, the constructor will throw a {@link SentryException}. Note that\n * without a valid Dsn, the SDK will not send any events to Sentry.\n *\n * Before sending an event, it is passed through\n * {@link BaseClient._prepareEvent} to add SDK information and scope data\n * (breadcrumbs and context). To add more custom information, override this\n * method and extend the resulting prepared event.\n *\n * To issue automatically created events (e.g. via instrumentation), use\n * {@link Client.captureEvent}. It will prepare the event and pass it through\n * the callback lifecycle. To issue auto-breadcrumbs, use\n * {@link Client.addBreadcrumb}.\n *\n * @example\n * class NodeClient extends BaseClient<NodeOptions> {\n *   public constructor(options: NodeOptions) {\n *     super(options);\n *   }\n *\n *   // ...\n * }\n */\nclass BaseClient {\n  /** Options passed to the SDK. */\n\n  /** The client Dsn, if specified in options. Without this Dsn, the SDK will be disabled. */\n\n  /** Array of set up integrations. */\n   __init() {this._integrations = {};}\n\n  /** Indicates whether this client's integrations have been set up. */\n   __init2() {this._integrationsInitialized = false;}\n\n  /** Number of calls being processed */\n   __init3() {this._numProcessing = 0;}\n\n  /** Holds flushable  */\n   __init4() {this._outcomes = {};}\n\n  /**\n   * Initializes this client instance.\n   *\n   * @param options Options for the client.\n   */\n   constructor(options) {;BaseClient.prototype.__init.call(this);BaseClient.prototype.__init2.call(this);BaseClient.prototype.__init3.call(this);BaseClient.prototype.__init4.call(this);\n    this._options = options;\n    if (options.dsn) {\n      this._dsn = makeDsn(options.dsn);\n      const url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, options);\n      this._transport = options.transport({\n        recordDroppedEvent: this.recordDroppedEvent.bind(this),\n        ...options.transportOptions,\n        url,\n      });\n    } else {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('No DSN provided, client will not do anything.');\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n   captureException(exception, hint, scope) {\n    // ensure we haven't captured this very object before\n    if (checkOrSetAlreadyCaught(exception)) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(ALREADY_SEEN_ERROR);\n      return;\n    }\n\n    let eventId = hint && hint.event_id;\n\n    this._process(\n      this.eventFromException(exception, hint)\n        .then(event => this._captureEvent(event, hint, scope))\n        .then(result => {\n          eventId = result;\n        }),\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    scope,\n  ) {\n    let eventId = hint && hint.event_id;\n\n    const promisedEvent = isPrimitive(message)\n      ? this.eventFromMessage(String(message), level, hint)\n      : this.eventFromException(message, hint);\n\n    this._process(\n      promisedEvent\n        .then(event => this._captureEvent(event, hint, scope))\n        .then(result => {\n          eventId = result;\n        }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureEvent(event, hint, scope) {\n    // ensure we haven't captured this very object before\n    if (hint && hint.originalException && checkOrSetAlreadyCaught(hint.originalException)) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(ALREADY_SEEN_ERROR);\n      return;\n    }\n\n    let eventId = hint && hint.event_id;\n\n    this._process(\n      this._captureEvent(event, hint, scope).then(result => {\n        eventId = result;\n      }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureSession(session) {\n    if (!this._isEnabled()) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('SDK not enabled, will not capture session.');\n      return;\n    }\n\n    if (!(typeof session.release === 'string')) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Discarded session because of missing or non-string release');\n    } else {\n      this.sendSession(session);\n      // After sending, we set init false to indicate it's not the first occurrence\n      updateSession(session, { init: false });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getDsn() {\n    return this._dsn;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getOptions() {\n    return this._options;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getTransport() {\n    return this._transport;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   flush(timeout) {\n    const transport = this._transport;\n    if (transport) {\n      return this._isClientDoneProcessing(timeout).then(clientFinished => {\n        return transport.flush(timeout).then(transportFlushed => clientFinished && transportFlushed);\n      });\n    } else {\n      return resolvedSyncPromise(true);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   close(timeout) {\n    return this.flush(timeout).then(result => {\n      this.getOptions().enabled = false;\n      return result;\n    });\n  }\n\n  /**\n   * Sets up the integrations\n   */\n   setupIntegrations() {\n    if (this._isEnabled() && !this._integrationsInitialized) {\n      this._integrations = setupIntegrations(this._options.integrations);\n      this._integrationsInitialized = true;\n    }\n  }\n\n  /**\n   * Gets an installed integration by its `id`.\n   *\n   * @returns The installed integration or `undefined` if no integration with that `id` was installed.\n   */\n   getIntegrationById(integrationId) {\n    return this._integrations[integrationId];\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getIntegration(integration) {\n    try {\n      return (this._integrations[integration.id] ) || null;\n    } catch (_oO) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Cannot retrieve integration ${integration.id} from the current Client`);\n      return null;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   sendEvent(event, hint = {}) {\n    if (this._dsn) {\n      let env = createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);\n\n      for (const attachment of hint.attachments || []) {\n        env = addItemToEnvelope(\n          env,\n          createAttachmentEnvelopeItem(\n            attachment,\n            this._options.transportOptions && this._options.transportOptions.textEncoder,\n          ),\n        );\n      }\n\n      this._sendEnvelope(env);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   sendSession(session) {\n    if (this._dsn) {\n      const env = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);\n      this._sendEnvelope(env);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   recordDroppedEvent(reason, category) {\n    if (this._options.sendClientReports) {\n      // We want to track each category (error, transaction, session) separately\n      // but still keep the distinction between different type of outcomes.\n      // We could use nested maps, but it's much easier to read and type this way.\n      // A correct type for map-based implementation if we want to go that route\n      // would be `Partial<Record<SentryRequestType, Partial<Record<Outcome, number>>>>`\n      // With typescript 4.1 we could even use template literal types\n      const key = `${reason}:${category}`;\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Adding outcome: \"${key}\"`);\n\n      // The following works because undefined + 1 === NaN and NaN is falsy\n      this._outcomes[key] = this._outcomes[key] + 1 || 1;\n    }\n  }\n\n  /** Updates existing session based on the provided event */\n   _updateSessionFromEvent(session, event) {\n    let crashed = false;\n    let errored = false;\n    const exceptions = event.exception && event.exception.values;\n\n    if (exceptions) {\n      errored = true;\n\n      for (const ex of exceptions) {\n        const mechanism = ex.mechanism;\n        if (mechanism && mechanism.handled === false) {\n          crashed = true;\n          break;\n        }\n      }\n    }\n\n    // A session is updated and that session update is sent in only one of the two following scenarios:\n    // 1. Session with non terminal status and 0 errors + an error occurred -> Will set error count to 1 and send update\n    // 2. Session with non terminal status and 1 error + a crash occurred -> Will set status crashed and send update\n    const sessionNonTerminal = session.status === 'ok';\n    const shouldUpdateAndSend = (sessionNonTerminal && session.errors === 0) || (sessionNonTerminal && crashed);\n\n    if (shouldUpdateAndSend) {\n      updateSession(session, {\n        ...(crashed && { status: 'crashed' }),\n        errors: session.errors || Number(errored || crashed),\n      });\n      this.captureSession(session);\n    }\n  }\n\n  /**\n   * Determine if the client is finished processing. Returns a promise because it will wait `timeout` ms before saying\n   * \"no\" (resolving to `false`) in order to give the client a chance to potentially finish first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the client is still busy. Passing `0` (or not\n   * passing anything) will make the promise wait as long as it takes for processing to finish before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if processing is already done or finishes before the timeout, and\n   * `false` otherwise\n   */\n   _isClientDoneProcessing(timeout) {\n    return new SyncPromise(resolve => {\n      let ticked = 0;\n      const tick = 1;\n\n      const interval = setInterval(() => {\n        if (this._numProcessing == 0) {\n          clearInterval(interval);\n          resolve(true);\n        } else {\n          ticked += tick;\n          if (timeout && ticked >= timeout) {\n            clearInterval(interval);\n            resolve(false);\n          }\n        }\n      }, tick);\n    });\n  }\n\n  /** Determines whether this SDK is enabled and a valid Dsn is present. */\n   _isEnabled() {\n    return this.getOptions().enabled !== false && this._dsn !== undefined;\n  }\n\n  /**\n   * Adds common information to events.\n   *\n   * The information includes release and environment from `options`,\n   * breadcrumbs and context (extra, tags and user) from the scope.\n   *\n   * Information that is already present in the event is never overwritten. For\n   * nested objects, such as the context, keys are merged.\n   *\n   * @param event The original event.\n   * @param hint May contain additional information about the original exception.\n   * @param scope A scope containing event metadata.\n   * @returns A new event with more information.\n   */\n   _prepareEvent(event, hint, scope) {\n    const { normalizeDepth = 3, normalizeMaxBreadth = 1000 } = this.getOptions();\n    const prepared = {\n      ...event,\n      event_id: event.event_id || hint.event_id || uuid4(),\n      timestamp: event.timestamp || dateTimestampInSeconds(),\n    };\n\n    this._applyClientOptions(prepared);\n    this._applyIntegrationsMetadata(prepared);\n\n    // If we have scope given to us, use it as the base for further modifications.\n    // This allows us to prevent unnecessary copying of data if `captureContext` is not provided.\n    let finalScope = scope;\n    if (hint.captureContext) {\n      finalScope = Scope.clone(finalScope).update(hint.captureContext);\n    }\n\n    // We prepare the result here with a resolved Event.\n    let result = resolvedSyncPromise(prepared);\n\n    // This should be the last thing called, since we want that\n    // {@link Hub.addEventProcessor} gets the finished prepared event.\n    if (finalScope) {\n      // Collect attachments from the hint and scope\n      const attachments = [...(hint.attachments || []), ...finalScope.getAttachments()];\n\n      if (attachments.length) {\n        hint.attachments = attachments;\n      }\n\n      // In case we have a hub we reassign it.\n      result = finalScope.applyToEvent(prepared, hint);\n    }\n\n    return result.then(evt => {\n      if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {\n        return this._normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);\n      }\n      return evt;\n    });\n  }\n\n  /**\n   * Applies `normalize` function on necessary `Event` attributes to make them safe for serialization.\n   * Normalized keys:\n   * - `breadcrumbs.data`\n   * - `user`\n   * - `contexts`\n   * - `extra`\n   * @param event Event\n   * @returns Normalized event\n   */\n   _normalizeEvent(event, depth, maxBreadth) {\n    if (!event) {\n      return null;\n    }\n\n    const normalized = {\n      ...event,\n      ...(event.breadcrumbs && {\n        breadcrumbs: event.breadcrumbs.map(b => ({\n          ...b,\n          ...(b.data && {\n            data: normalize(b.data, depth, maxBreadth),\n          }),\n        })),\n      }),\n      ...(event.user && {\n        user: normalize(event.user, depth, maxBreadth),\n      }),\n      ...(event.contexts && {\n        contexts: normalize(event.contexts, depth, maxBreadth),\n      }),\n      ...(event.extra && {\n        extra: normalize(event.extra, depth, maxBreadth),\n      }),\n    };\n\n    // event.contexts.trace stores information about a Transaction. Similarly,\n    // event.spans[] stores information about child Spans. Given that a\n    // Transaction is conceptually a Span, normalization should apply to both\n    // Transactions and Spans consistently.\n    // For now the decision is to skip normalization of Transactions and Spans,\n    // so this block overwrites the normalized event to add back the original\n    // Transaction information prior to normalization.\n    if (event.contexts && event.contexts.trace && normalized.contexts) {\n      normalized.contexts.trace = event.contexts.trace;\n\n      // event.contexts.trace.data may contain circular/dangerous data so we need to normalize it\n      if (event.contexts.trace.data) {\n        normalized.contexts.trace.data = normalize(event.contexts.trace.data, depth, maxBreadth);\n      }\n    }\n\n    // event.spans[].data may contain circular/dangerous data so we need to normalize it\n    if (event.spans) {\n      normalized.spans = event.spans.map(span => {\n        // We cannot use the spread operator here because `toJSON` on `span` is non-enumerable\n        if (span.data) {\n          span.data = normalize(span.data, depth, maxBreadth);\n        }\n        return span;\n      });\n    }\n\n    return normalized;\n  }\n\n  /**\n   *  Enhances event using the client configuration.\n   *  It takes care of all \"static\" values like environment, release and `dist`,\n   *  as well as truncating overly long values.\n   * @param event event instance to be enhanced\n   */\n   _applyClientOptions(event) {\n    const options = this.getOptions();\n    const { environment, release, dist, maxValueLength = 250 } = options;\n\n    if (!('environment' in event)) {\n      event.environment = 'environment' in options ? environment : 'production';\n    }\n\n    if (event.release === undefined && release !== undefined) {\n      event.release = release;\n    }\n\n    if (event.dist === undefined && dist !== undefined) {\n      event.dist = dist;\n    }\n\n    if (event.message) {\n      event.message = truncate(event.message, maxValueLength);\n    }\n\n    const exception = event.exception && event.exception.values && event.exception.values[0];\n    if (exception && exception.value) {\n      exception.value = truncate(exception.value, maxValueLength);\n    }\n\n    const request = event.request;\n    if (request && request.url) {\n      request.url = truncate(request.url, maxValueLength);\n    }\n  }\n\n  /**\n   * This function adds all used integrations to the SDK info in the event.\n   * @param event The event that will be filled with all integrations.\n   */\n   _applyIntegrationsMetadata(event) {\n    const integrationsArray = Object.keys(this._integrations);\n    if (integrationsArray.length > 0) {\n      event.sdk = event.sdk || {};\n      event.sdk.integrations = [...(event.sdk.integrations || []), ...integrationsArray];\n    }\n  }\n\n  /**\n   * Processes the event and logs an error in case of rejection\n   * @param event\n   * @param hint\n   * @param scope\n   */\n   _captureEvent(event, hint = {}, scope) {\n    return this._processEvent(event, hint, scope).then(\n      finalEvent => {\n        return finalEvent.event_id;\n      },\n      reason => {\n        if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n          // If something's gone wrong, log the error as a warning. If it's just us having used a `SentryError` for\n          // control flow, log just the message (no stack) as a log-level log.\n          const sentryError = reason ;\n          if (sentryError.logLevel === 'log') {\n            logger.log(sentryError.message);\n          } else {\n            logger.warn(sentryError);\n          }\n        }\n        return undefined;\n      },\n    );\n  }\n\n  /**\n   * Processes an event (either error or message) and sends it to Sentry.\n   *\n   * This also adds breadcrumbs and context information to the event. However,\n   * platform specific meta data (such as the User's IP address) must be added\n   * by the SDK implementor.\n   *\n   *\n   * @param event The event to send to Sentry.\n   * @param hint May contain additional information about the original exception.\n   * @param scope A scope containing event metadata.\n   * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.\n   */\n   _processEvent(event, hint, scope) {\n    const { beforeSend, sampleRate } = this.getOptions();\n\n    if (!this._isEnabled()) {\n      return rejectedSyncPromise(new SentryError('SDK not enabled, will not capture event.', 'log'));\n    }\n\n    const isTransaction = event.type === 'transaction';\n    // 1.0 === 100% events are sent\n    // 0.0 === 0% events are sent\n    // Sampling for transaction happens somewhere else\n    if (!isTransaction && typeof sampleRate === 'number' && Math.random() > sampleRate) {\n      this.recordDroppedEvent('sample_rate', 'error');\n      return rejectedSyncPromise(\n        new SentryError(\n          `Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`,\n          'log',\n        ),\n      );\n    }\n\n    return this._prepareEvent(event, hint, scope)\n      .then(prepared => {\n        if (prepared === null) {\n          this.recordDroppedEvent('event_processor', event.type || 'error');\n          throw new SentryError('An event processor returned null, will not send event.', 'log');\n        }\n\n        const isInternalException = hint.data && (hint.data ).__sentry__ === true;\n        if (isInternalException || isTransaction || !beforeSend) {\n          return prepared;\n        }\n\n        const beforeSendResult = beforeSend(prepared, hint);\n        return _ensureBeforeSendRv(beforeSendResult);\n      })\n      .then(processedEvent => {\n        if (processedEvent === null) {\n          this.recordDroppedEvent('before_send', event.type || 'error');\n          throw new SentryError('`beforeSend` returned `null`, will not send event.', 'log');\n        }\n\n        const session = scope && scope.getSession();\n        if (!isTransaction && session) {\n          this._updateSessionFromEvent(session, processedEvent);\n        }\n\n        // None of the Sentry built event processor will update transaction name,\n        // so if the transaction name has been changed by an event processor, we know\n        // it has to come from custom event processor added by a user\n        const transactionInfo = processedEvent.transaction_info;\n        if (isTransaction && transactionInfo && processedEvent.transaction !== event.transaction) {\n          const source = 'custom';\n          processedEvent.transaction_info = {\n            ...transactionInfo,\n            source,\n            changes: [\n              ...transactionInfo.changes,\n              {\n                source,\n                // use the same timestamp as the processed event.\n                timestamp: processedEvent.timestamp ,\n                propagations: transactionInfo.propagations,\n              },\n            ],\n          };\n        }\n\n        this.sendEvent(processedEvent, hint);\n        return processedEvent;\n      })\n      .then(null, reason => {\n        if (reason instanceof SentryError) {\n          throw reason;\n        }\n\n        this.captureException(reason, {\n          data: {\n            __sentry__: true,\n          },\n          originalException: reason ,\n        });\n        throw new SentryError(\n          `Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\\nReason: ${reason}`,\n        );\n      });\n  }\n\n  /**\n   * Occupies the client with processing and event\n   */\n   _process(promise) {\n    this._numProcessing += 1;\n    void promise.then(\n      value => {\n        this._numProcessing -= 1;\n        return value;\n      },\n      reason => {\n        this._numProcessing -= 1;\n        return reason;\n      },\n    );\n  }\n\n  /**\n   * @inheritdoc\n   */\n   _sendEnvelope(envelope) {\n    if (this._transport && this._dsn) {\n      this._transport.send(envelope).then(null, reason => {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Error while sending event:', reason);\n      });\n    } else {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Transport disabled');\n    }\n  }\n\n  /**\n   * Clears outcomes on this client and returns them.\n   */\n   _clearOutcomes() {\n    const outcomes = this._outcomes;\n    this._outcomes = {};\n    return Object.keys(outcomes).map(key => {\n      const [reason, category] = key.split(':') ;\n      return {\n        reason,\n        category,\n        quantity: outcomes[key],\n      };\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n\n}\n\n/**\n * Verifies that return value of configured `beforeSend` is of expected type.\n */\nfunction _ensureBeforeSendRv(rv) {\n  const nullErr = '`beforeSend` method has to return `null` or a valid event.';\n  if (isThenable(rv)) {\n    return rv.then(\n      event => {\n        if (!(isPlainObject(event) || event === null)) {\n          throw new SentryError(nullErr);\n        }\n        return event;\n      },\n      e => {\n        throw new SentryError(`beforeSend rejected with ${e}`);\n      },\n    );\n  } else if (!(isPlainObject(rv) || rv === null)) {\n    throw new SentryError(nullErr);\n  }\n  return rv;\n}\n\nexport { BaseClient };\n//# sourceMappingURL=baseclient.js.map\n","import { getCurrentHub } from '@sentry/core';\nimport { isEvent, extractExceptionKeysForMessage, normalizeToSize, addExceptionMechanism, resolvedSyncPromise, isErrorEvent, isDOMError, isDOMException, addExceptionTypeValue, isError, isPlainObject } from '@sentry/utils';\n\n/**\n * This function creates an exception from a JavaScript Error\n */\nfunction exceptionFromError(stackParser, ex) {\n  // Get the frames first since Opera can lose the stack if we touch anything else first\n  const frames = parseStackFrames(stackParser, ex);\n\n  const exception = {\n    type: ex && ex.name,\n    value: extractMessage(ex),\n  };\n\n  if (frames.length) {\n    exception.stacktrace = { frames };\n  }\n\n  if (exception.type === undefined && exception.value === '') {\n    exception.value = 'Unrecoverable error caught';\n  }\n\n  return exception;\n}\n\n/**\n * @hidden\n */\nfunction eventFromPlainObject(\n  stackParser,\n  exception,\n  syntheticException,\n  isUnhandledRejection,\n) {\n  const hub = getCurrentHub();\n  const client = hub.getClient();\n  const normalizeDepth = client && client.getOptions().normalizeDepth;\n\n  const event = {\n    exception: {\n      values: [\n        {\n          type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',\n          value: `Non-Error ${\n            isUnhandledRejection ? 'promise rejection' : 'exception'\n          } captured with keys: ${extractExceptionKeysForMessage(exception)}`,\n        },\n      ],\n    },\n    extra: {\n      __serialized__: normalizeToSize(exception, normalizeDepth),\n    },\n  };\n\n  if (syntheticException) {\n    const frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      // event.exception.values[0] has been set above\n      (event.exception ).values[0].stacktrace = { frames };\n    }\n  }\n\n  return event;\n}\n\n/**\n * @hidden\n */\nfunction eventFromError(stackParser, ex) {\n  return {\n    exception: {\n      values: [exceptionFromError(stackParser, ex)],\n    },\n  };\n}\n\n/** Parses stack frames from an error */\nfunction parseStackFrames(\n  stackParser,\n  ex,\n) {\n  // Access and store the stacktrace property before doing ANYTHING\n  // else to it because Opera is not very good at providing it\n  // reliably in other circumstances.\n  const stacktrace = ex.stacktrace || ex.stack || '';\n\n  const popSize = getPopSize(ex);\n\n  try {\n    return stackParser(stacktrace, popSize);\n  } catch (e) {\n    // no-empty\n  }\n\n  return [];\n}\n\n// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108\nconst reactMinifiedRegexp = /Minified React error #\\d+;/i;\n\nfunction getPopSize(ex) {\n  if (ex) {\n    if (typeof ex.framesToPop === 'number') {\n      return ex.framesToPop;\n    }\n\n    if (reactMinifiedRegexp.test(ex.message)) {\n      return 1;\n    }\n  }\n\n  return 0;\n}\n\n/**\n * There are cases where stacktrace.message is an Event object\n * https://github.com/getsentry/sentry-javascript/issues/1949\n * In this specific case we try to extract stacktrace.message.error.message\n */\nfunction extractMessage(ex) {\n  const message = ex && ex.message;\n  if (!message) {\n    return 'No error message';\n  }\n  if (message.error && typeof message.error.message === 'string') {\n    return message.error.message;\n  }\n  return message;\n}\n\n/**\n * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.\n * @hidden\n */\nfunction eventFromException(\n  stackParser,\n  exception,\n  hint,\n  attachStacktrace,\n) {\n  const syntheticException = (hint && hint.syntheticException) || undefined;\n  const event = eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace);\n  addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }\n  event.level = 'error';\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * Builds and Event from a Message\n * @hidden\n */\nfunction eventFromMessage(\n  stackParser,\n  message,\n  // eslint-disable-next-line deprecation/deprecation\n  level = 'info',\n  hint,\n  attachStacktrace,\n) {\n  const syntheticException = (hint && hint.syntheticException) || undefined;\n  const event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n  event.level = level;\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * @hidden\n */\nfunction eventFromUnknownInput(\n  stackParser,\n  exception,\n  syntheticException,\n  attachStacktrace,\n  isUnhandledRejection,\n) {\n  let event;\n\n  if (isErrorEvent(exception ) && (exception ).error) {\n    // If it is an ErrorEvent with `error` property, extract it to get actual Error\n    const errorEvent = exception ;\n    return eventFromError(stackParser, errorEvent.error );\n  }\n\n  // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name\n  // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be\n  // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`.\n  //\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n  // https://webidl.spec.whatwg.org/#es-DOMException-specialness\n  if (isDOMError(exception ) || isDOMException(exception )) {\n    const domException = exception ;\n\n    if ('stack' in (exception )) {\n      event = eventFromError(stackParser, exception );\n    } else {\n      const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n      const message = domException.message ? `${name}: ${domException.message}` : name;\n      event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n      addExceptionTypeValue(event, message);\n    }\n    if ('code' in domException) {\n      event.tags = { ...event.tags, 'DOMException.code': `${domException.code}` };\n    }\n\n    return event;\n  }\n  if (isError(exception)) {\n    // we have a real Error object, do nothing\n    return eventFromError(stackParser, exception);\n  }\n  if (isPlainObject(exception) || isEvent(exception)) {\n    // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize\n    // it manually. This will allow us to group events based on top-level keys which is much better than creating a new\n    // group on any key/value change.\n    const objectException = exception ;\n    event = eventFromPlainObject(stackParser, objectException, syntheticException, isUnhandledRejection);\n    addExceptionMechanism(event, {\n      synthetic: true,\n    });\n    return event;\n  }\n\n  // If none of previous checks were valid, then it means that it's not:\n  // - an instance of DOMError\n  // - an instance of DOMException\n  // - an instance of Event\n  // - an instance of Error\n  // - a valid ErrorEvent (one with an error property)\n  // - a plain Object\n  //\n  // So bail out and capture it as a simple message:\n  event = eventFromString(stackParser, exception , syntheticException, attachStacktrace);\n  addExceptionTypeValue(event, `${exception}`, undefined);\n  addExceptionMechanism(event, {\n    synthetic: true,\n  });\n\n  return event;\n}\n\n/**\n * @hidden\n */\nfunction eventFromString(\n  stackParser,\n  input,\n  syntheticException,\n  attachStacktrace,\n) {\n  const event = {\n    message: input,\n  };\n\n  if (attachStacktrace && syntheticException) {\n    const frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      event.exception = {\n        values: [{ value: input, stacktrace: { frames } }],\n      };\n    }\n  }\n\n  return event;\n}\n\nexport { eventFromError, eventFromException, eventFromMessage, eventFromPlainObject, eventFromString, eventFromUnknownInput, exceptionFromError, parseStackFrames };\n//# sourceMappingURL=eventbuilder.js.map\n","import { getCurrentHub } from './hub.js';\n\n// Note: All functions in this file are typed with a return value of `ReturnType<Hub[HUB_FUNCTION]>`,\n// where HUB_FUNCTION is some method on the Hub class.\n//\n// This is done to make sure the top level SDK methods stay in sync with the hub methods.\n// Although every method here has an explicit return type, some of them (that map to void returns) do not\n// contain `return` keywords. This is done to save on bundle size, as `return` is not minifiable.\n\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception An exception-like object.\n * @param captureContext Additional scope data to apply to exception event.\n * @returns The generated eventId.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nfunction captureException(exception, captureContext) {\n  return getCurrentHub().captureException(exception, { captureContext });\n}\n\n/**\n * Captures a message event and sends it to Sentry.\n *\n * @param message The message to send to Sentry.\n * @param Severity Define the level of the message.\n * @returns The generated eventId.\n */\nfunction captureMessage(\n  message,\n  // eslint-disable-next-line deprecation/deprecation\n  captureContext,\n) {\n  // This is necessary to provide explicit scopes upgrade, without changing the original\n  // arity of the `captureMessage(message, level)` method.\n  const level = typeof captureContext === 'string' ? captureContext : undefined;\n  const context = typeof captureContext !== 'string' ? { captureContext } : undefined;\n  return getCurrentHub().captureMessage(message, level, context);\n}\n\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @returns The generated eventId.\n */\nfunction captureEvent(event, hint) {\n  return getCurrentHub().captureEvent(event, hint);\n}\n\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n */\nfunction configureScope(callback) {\n  getCurrentHub().configureScope(callback);\n}\n\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on\n * user's actions prior to an error or crash.\n *\n * @param breadcrumb The breadcrumb to record.\n */\nfunction addBreadcrumb(breadcrumb) {\n  getCurrentHub().addBreadcrumb(breadcrumb);\n}\n\n/**\n * Sets context data with the given name.\n * @param name of the context\n * @param context Any kind of data. This data will be normalized.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction setContext(name, context) {\n  getCurrentHub().setContext(name, context);\n}\n\n/**\n * Set an object that will be merged sent as extra data with the event.\n * @param extras Extras object to merge into current context.\n */\nfunction setExtras(extras) {\n  getCurrentHub().setExtras(extras);\n}\n\n/**\n * Set key:value that will be sent as extra data with the event.\n * @param key String of extra\n * @param extra Any kind of data. This data will be normalized.\n */\nfunction setExtra(key, extra) {\n  getCurrentHub().setExtra(key, extra);\n}\n\n/**\n * Set an object that will be merged sent as tags data with the event.\n * @param tags Tags context object to merge into current context.\n */\nfunction setTags(tags) {\n  getCurrentHub().setTags(tags);\n}\n\n/**\n * Set key:value that will be sent as tags data with the event.\n *\n * Can also be used to unset a tag, by passing `undefined`.\n *\n * @param key String key of tag\n * @param value Value of tag\n */\nfunction setTag(key, value) {\n  getCurrentHub().setTag(key, value);\n}\n\n/**\n * Updates user context information for future events.\n *\n * @param user User context object to be set in the current context. Pass `null` to unset the user.\n */\nfunction setUser(user) {\n  getCurrentHub().setUser(user);\n}\n\n/**\n * Creates a new scope with and executes the given operation within.\n * The scope is automatically removed once the operation\n * finishes or throws.\n *\n * This is essentially a convenience function for:\n *\n *     pushScope();\n *     callback();\n *     popScope();\n *\n * @param callback that will be enclosed into push/popScope.\n */\nfunction withScope(callback) {\n  getCurrentHub().withScope(callback);\n}\n\n/**\n * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.\n *\n * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a\n * new child span within the transaction or any span, call the respective `.startChild()` method.\n *\n * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.\n *\n * The transaction must be finished with a call to its `.finish()` method, at which point the transaction with all its\n * finished child spans will be sent to Sentry.\n *\n * NOTE: This function should only be used for *manual* instrumentation. Auto-instrumentation should call\n * `startTransaction` directly on the hub.\n *\n * @param context Properties of the new `Transaction`.\n * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent\n * default values). See {@link Options.tracesSampler}.\n *\n * @returns The transaction which was just started\n */\nfunction startTransaction(\n  context,\n  customSamplingContext,\n) {\n  return getCurrentHub().startTransaction({ ...context }, customSamplingContext);\n}\n\nexport { addBreadcrumb, captureEvent, captureException, captureMessage, configureScope, setContext, setExtra, setExtras, setTag, setTags, setUser, startTransaction, withScope };\n//# sourceMappingURL=exports.js.map\n","import { withScope, captureException } from '@sentry/core';\nimport { GLOBAL_OBJ, getOriginalFunction, addExceptionTypeValue, addExceptionMechanism, markFunctionWrapped, addNonEnumerableProperty } from '@sentry/utils';\n\nconst WINDOW = GLOBAL_OBJ ;\n\nlet ignoreOnError = 0;\n\n/**\n * @hidden\n */\nfunction shouldIgnoreOnError() {\n  return ignoreOnError > 0;\n}\n\n/**\n * @hidden\n */\nfunction ignoreNextOnError() {\n  // onerror should trigger before setTimeout\n  ignoreOnError += 1;\n  setTimeout(() => {\n    ignoreOnError -= 1;\n  });\n}\n\n/**\n * Instruments the given function and sends an event to Sentry every time the\n * function throws an exception.\n *\n * @param fn A function to wrap. It is generally safe to pass an unbound function, because the returned wrapper always\n * has a correct `this` context.\n * @returns The wrapped function.\n * @hidden\n */\nfunction wrap(\n  fn,\n  options\n\n = {},\n  before,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n) {\n  // for future readers what this does is wrap a function and then create\n  // a bi-directional wrapping between them.\n  //\n  // example: wrapped = wrap(original);\n  //  original.__sentry_wrapped__ -> wrapped\n  //  wrapped.__sentry_original__ -> original\n\n  if (typeof fn !== 'function') {\n    return fn;\n  }\n\n  try {\n    // if we're dealing with a function that was previously wrapped, return\n    // the original wrapper.\n    const wrapper = fn.__sentry_wrapped__;\n    if (wrapper) {\n      return wrapper;\n    }\n\n    // We don't wanna wrap it twice\n    if (getOriginalFunction(fn)) {\n      return fn;\n    }\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    // Bail on wrapping and return the function as-is (defers to window.onerror).\n    return fn;\n  }\n\n  /* eslint-disable prefer-rest-params */\n  // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`\n  const sentryWrapped = function () {\n    const args = Array.prototype.slice.call(arguments);\n\n    try {\n      if (before && typeof before === 'function') {\n        before.apply(this, arguments);\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access\n      const wrappedArguments = args.map((arg) => wrap(arg, options));\n\n      // Attempt to invoke user-land function\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n      //       means the sentry.javascript SDK caught an error invoking your application code. This\n      //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n      return fn.apply(this, wrappedArguments);\n    } catch (ex) {\n      ignoreNextOnError();\n\n      withScope((scope) => {\n        scope.addEventProcessor((event) => {\n          if (options.mechanism) {\n            addExceptionTypeValue(event, undefined, undefined);\n            addExceptionMechanism(event, options.mechanism);\n          }\n\n          event.extra = {\n            ...event.extra,\n            arguments: args,\n          };\n\n          return event;\n        });\n\n        captureException(ex);\n      });\n\n      throw ex;\n    }\n  };\n  /* eslint-enable prefer-rest-params */\n\n  // Accessing some objects may throw\n  // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n  try {\n    for (const property in fn) {\n      if (Object.prototype.hasOwnProperty.call(fn, property)) {\n        sentryWrapped[property] = fn[property];\n      }\n    }\n  } catch (_oO) {} // eslint-disable-line no-empty\n\n  // Signal that this function has been wrapped/filled already\n  // for both debugging and to prevent it to being wrapped/filled twice\n  markFunctionWrapped(sentryWrapped, fn);\n\n  addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);\n\n  // Restore original function name (not all browsers allow that)\n  try {\n    const descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name') ;\n    if (descriptor.configurable) {\n      Object.defineProperty(sentryWrapped, 'name', {\n        get() {\n          return fn.name;\n        },\n      });\n    }\n    // eslint-disable-next-line no-empty\n  } catch (_oO) {}\n\n  return sentryWrapped;\n}\n\n/**\n * All properties the report dialog supports\n */\n\nexport { WINDOW, ignoreNextOnError, shouldIgnoreOnError, wrap };\n//# sourceMappingURL=helpers.js.map\n","// Note: Ideally the `SeverityLevel` type would be derived from `validSeverityLevels`, but that would mean either\n//\n// a) moving `validSeverityLevels` to `@sentry/types`,\n// b) moving the`SeverityLevel` type here, or\n// c) importing `validSeverityLevels` from here into `@sentry/types`.\n//\n// Option A would make `@sentry/types` a runtime dependency of `@sentry/utils` (not good), and options B and C would\n// create a circular dependency between `@sentry/types` and `@sentry/utils` (also not good). So a TODO accompanying the\n// type, reminding anyone who changes it to change this list also, will have to do.\n\nconst validSeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'];\n\n/**\n * Converts a string-based level into a member of the deprecated {@link Severity} enum.\n *\n * @deprecated `severityFromString` is deprecated. Please use `severityLevelFromString` instead.\n *\n * @param level String representation of Severity\n * @returns Severity\n */\nfunction severityFromString(level) {\n  return severityLevelFromString(level) ;\n}\n\n/**\n * Converts a string-based level into a `SeverityLevel`, normalizing it along the way.\n *\n * @param level String representation of desired `SeverityLevel`.\n * @returns The `SeverityLevel` corresponding to the given string, or 'log' if the string isn't a valid level.\n */\nfunction severityLevelFromString(level) {\n  return (level === 'warn' ? 'warning' : validSeverityLevels.includes(level) ? level : 'log') ;\n}\n\nexport { severityFromString, severityLevelFromString, validSeverityLevels };\n//# sourceMappingURL=severity.js.map\n","/**\n * Parses string form of URL into an object\n * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n * // intentionally using regex and not <a/> href parsing trick because React Native and other\n * // environments where DOM might not be available\n * @returns parsed URL object\n */\nfunction parseUrl(url)\n\n {\n  if (!url) {\n    return {};\n  }\n\n  const match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n\n  if (!match) {\n    return {};\n  }\n\n  // coerce to undefined values to empty string so we don't get 'undefined'\n  const query = match[6] || '';\n  const fragment = match[8] || '';\n  return {\n    host: match[4],\n    path: match[5],\n    protocol: match[2],\n    relative: match[5] + query + fragment, // everything minus origin\n  };\n}\n\n/**\n * Strip the query string and fragment off of a given URL or path (if present)\n *\n * @param urlPath Full URL or path, including possible query string and/or fragment\n * @returns URL or path without query string or fragment\n */\nfunction stripUrlQueryAndFragment(urlPath) {\n  // eslint-disable-next-line no-useless-escape\n  return urlPath.split(/[\\?#]/, 1)[0];\n}\n\n/**\n * Returns number of URL segments of a passed string URL.\n */\nfunction getNumberOfUrlSegments(url) {\n  // split at '/' or at '\\/' to split regex urls correctly\n  return url.split(/\\\\?\\//).filter(s => s.length > 0 && s !== ',').length;\n}\n\nexport { getNumberOfUrlSegments, parseUrl, stripUrlQueryAndFragment };\n//# sourceMappingURL=url.js.map\n","import { getCurrentHub } from '@sentry/core';\nimport { addInstrumentationHandler, htmlTreeAsString, severityLevelFromString, safeJoin, parseUrl } from '@sentry/utils';\nimport { WINDOW } from '../helpers.js';\n\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n\n/** JSDoc */\n\nconst BREADCRUMB_INTEGRATION_ID = 'Breadcrumbs';\n\n/**\n * Default Breadcrumbs instrumentations\n * TODO: Deprecated - with v6, this will be renamed to `Instrument`\n */\nclass Breadcrumbs  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = BREADCRUMB_INTEGRATION_ID;}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = Breadcrumbs.id;}\n\n  /**\n   * Options of the breadcrumbs integration.\n   */\n  // This field is public, because we use it in the browser client to check if the `sentry` option is enabled.\n\n  /**\n   * @inheritDoc\n   */\n   constructor(options) {;Breadcrumbs.prototype.__init.call(this);\n    this.options = {\n      console: true,\n      dom: true,\n      fetch: true,\n      history: true,\n      sentry: true,\n      xhr: true,\n      ...options,\n    };\n  }\n\n  /**\n   * Instrument browser built-ins w/ breadcrumb capturing\n   *  - Console API\n   *  - DOM API (click/typing)\n   *  - XMLHttpRequest API\n   *  - Fetch API\n   *  - History API\n   */\n   setupOnce() {\n    if (this.options.console) {\n      addInstrumentationHandler('console', _consoleBreadcrumb);\n    }\n    if (this.options.dom) {\n      addInstrumentationHandler('dom', _domBreadcrumb(this.options.dom));\n    }\n    if (this.options.xhr) {\n      addInstrumentationHandler('xhr', _xhrBreadcrumb);\n    }\n    if (this.options.fetch) {\n      addInstrumentationHandler('fetch', _fetchBreadcrumb);\n    }\n    if (this.options.history) {\n      addInstrumentationHandler('history', _historyBreadcrumb);\n    }\n  }\n} Breadcrumbs.__initStatic();\n\n/**\n * A HOC that creaes a function that creates breadcrumbs from DOM API calls.\n * This is a HOC so that we get access to dom options in the closure.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _domBreadcrumb(dom) {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  function _innerDomBreadcrumb(handlerData) {\n    let target;\n    let keyAttrs = typeof dom === 'object' ? dom.serializeAttribute : undefined;\n\n    if (typeof keyAttrs === 'string') {\n      keyAttrs = [keyAttrs];\n    }\n\n    // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n    try {\n      target = handlerData.event.target\n        ? htmlTreeAsString(handlerData.event.target , keyAttrs)\n        : htmlTreeAsString(handlerData.event , keyAttrs);\n    } catch (e) {\n      target = '<unknown>';\n    }\n\n    if (target.length === 0) {\n      return;\n    }\n\n    getCurrentHub().addBreadcrumb(\n      {\n        category: `ui.${handlerData.name}`,\n        message: target,\n      },\n      {\n        event: handlerData.event,\n        name: handlerData.name,\n        global: handlerData.global,\n      },\n    );\n  }\n\n  return _innerDomBreadcrumb;\n}\n\n/**\n * Creates breadcrumbs from console API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _consoleBreadcrumb(handlerData) {\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/6010\n  // see: https://github.com/getsentry/sentry-javascript/issues/5916\n  for (let i = 0; i < handlerData.args.length; i++) {\n    if (handlerData.args[i] === 'ref=Ref<') {\n      handlerData.args[i + 1] = 'viewRef';\n      break;\n    }\n  }\n  const breadcrumb = {\n    category: 'console',\n    data: {\n      arguments: handlerData.args,\n      logger: 'console',\n    },\n    level: severityLevelFromString(handlerData.level),\n    message: safeJoin(handlerData.args, ' '),\n  };\n\n  if (handlerData.level === 'assert') {\n    if (handlerData.args[0] === false) {\n      breadcrumb.message = `Assertion failed: ${safeJoin(handlerData.args.slice(1), ' ') || 'console.assert'}`;\n      breadcrumb.data.arguments = handlerData.args.slice(1);\n    } else {\n      // Don't capture a breadcrumb for passed assertions\n      return;\n    }\n  }\n\n  getCurrentHub().addBreadcrumb(breadcrumb, {\n    input: handlerData.args,\n    level: handlerData.level,\n  });\n}\n\n/**\n * Creates breadcrumbs from XHR API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _xhrBreadcrumb(handlerData) {\n  if (handlerData.endTimestamp) {\n    // We only capture complete, non-sentry requests\n    if (handlerData.xhr.__sentry_own_request__) {\n      return;\n    }\n\n    const { method, url, status_code, body } = handlerData.xhr.__sentry_xhr__ || {};\n\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'xhr',\n        data: {\n          method,\n          url,\n          status_code,\n        },\n        type: 'http',\n      },\n      {\n        xhr: handlerData.xhr,\n        input: body,\n      },\n    );\n\n    return;\n  }\n}\n\n/**\n * Creates breadcrumbs from fetch API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _fetchBreadcrumb(handlerData) {\n  // We only capture complete fetch requests\n  if (!handlerData.endTimestamp) {\n    return;\n  }\n\n  if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {\n    // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)\n    return;\n  }\n\n  if (handlerData.error) {\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'fetch',\n        data: handlerData.fetchData,\n        level: 'error',\n        type: 'http',\n      },\n      {\n        data: handlerData.error,\n        input: handlerData.args,\n      },\n    );\n  } else {\n    getCurrentHub().addBreadcrumb(\n      {\n        category: 'fetch',\n        data: {\n          ...handlerData.fetchData,\n          status_code: handlerData.response.status,\n        },\n        type: 'http',\n      },\n      {\n        input: handlerData.args,\n        response: handlerData.response,\n      },\n    );\n  }\n}\n\n/**\n * Creates breadcrumbs from history API calls\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _historyBreadcrumb(handlerData) {\n  let from = handlerData.from;\n  let to = handlerData.to;\n  const parsedLoc = parseUrl(WINDOW.location.href);\n  let parsedFrom = parseUrl(from);\n  const parsedTo = parseUrl(to);\n\n  // Initial pushState doesn't provide `from` information\n  if (!parsedFrom.path) {\n    parsedFrom = parsedLoc;\n  }\n\n  // Use only the path component of the URL if the URL matches the current\n  // document (almost all the time when using pushState)\n  if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {\n    to = parsedTo.relative;\n  }\n  if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n    from = parsedFrom.relative;\n  }\n\n  getCurrentHub().addBreadcrumb({\n    category: 'navigation',\n    data: {\n      from,\n      to,\n    },\n  });\n}\n\nexport { BREADCRUMB_INTEGRATION_ID, Breadcrumbs };\n//# sourceMappingURL=breadcrumbs.js.map\n","import { BaseClient, SDK_VERSION, getCurrentHub, getEnvelopeEndpointWithUrlEncodedAuth } from '@sentry/core';\nimport { getEventDescription, logger, createClientReportEnvelope, dsnToString, serializeEnvelope } from '@sentry/utils';\nimport { eventFromException, eventFromMessage } from './eventbuilder.js';\nimport { WINDOW } from './helpers.js';\nimport { BREADCRUMB_INTEGRATION_ID } from './integrations/breadcrumbs.js';\n\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\nclass BrowserClient extends BaseClient {\n  /**\n   * Creates a new Browser SDK instance.\n   *\n   * @param options Configuration options for this SDK.\n   */\n   constructor(options) {\n    options._metadata = options._metadata || {};\n    options._metadata.sdk = options._metadata.sdk || {\n      name: 'sentry.javascript.browser',\n      packages: [\n        {\n          name: 'npm:@sentry/browser',\n          version: SDK_VERSION,\n        },\n      ],\n      version: SDK_VERSION,\n    };\n\n    super(options);\n\n    if (options.sendClientReports && WINDOW.document) {\n      WINDOW.document.addEventListener('visibilitychange', () => {\n        if (WINDOW.document.visibilityState === 'hidden') {\n          this._flushOutcomes();\n        }\n      });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   eventFromException(exception, hint) {\n    return eventFromException(this._options.stackParser, exception, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   eventFromMessage(\n    message,\n    // eslint-disable-next-line deprecation/deprecation\n    level = 'info',\n    hint,\n  ) {\n    return eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   sendEvent(event, hint) {\n    // We only want to add the sentry event breadcrumb when the user has the breadcrumb integration installed and\n    // activated its `sentry` option.\n    // We also do not want to use the `Breadcrumbs` class here directly, because we do not want it to be included in\n    // bundles, if it is not used by the SDK.\n    // This all sadly is a bit ugly, but we currently don't have a \"pre-send\" hook on the integrations so we do it this\n    // way for now.\n    const breadcrumbIntegration = this.getIntegrationById(BREADCRUMB_INTEGRATION_ID) ;\n    if (\n      breadcrumbIntegration &&\n      // We check for definedness of `options`, even though it is not strictly necessary, because that access to\n      // `.sentry` below does not throw, in case users provided their own integration with id \"Breadcrumbs\" that does\n      // not have an`options` field\n      breadcrumbIntegration.options &&\n      breadcrumbIntegration.options.sentry\n    ) {\n      getCurrentHub().addBreadcrumb(\n        {\n          category: `sentry.${event.type === 'transaction' ? 'transaction' : 'event'}`,\n          event_id: event.event_id,\n          level: event.level,\n          message: getEventDescription(event),\n        },\n        {\n          event,\n        },\n      );\n    }\n\n    super.sendEvent(event, hint);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   _prepareEvent(event, hint, scope) {\n    event.platform = event.platform || 'javascript';\n    return super._prepareEvent(event, hint, scope);\n  }\n\n  /**\n   * Sends client reports as an envelope.\n   */\n   _flushOutcomes() {\n    const outcomes = this._clearOutcomes();\n\n    if (outcomes.length === 0) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('No outcomes to send');\n      return;\n    }\n\n    if (!this._dsn) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('No dsn provided, will not send outcomes');\n      return;\n    }\n\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('Sending outcomes:', outcomes);\n\n    const url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, this._options);\n    const envelope = createClientReportEnvelope(outcomes, this._options.tunnel && dsnToString(this._dsn));\n\n    try {\n      const isRealNavigator = Object.prototype.toString.call(WINDOW && WINDOW.navigator) === '[object Navigator]';\n      const hasSendBeacon = isRealNavigator && typeof WINDOW.navigator.sendBeacon === 'function';\n      // Make sure beacon is not used if user configures custom transport options\n      if (hasSendBeacon && !this._options.transportOptions) {\n        // Prevent illegal invocations - https://xgwang.me/posts/you-may-not-know-beacon/#it-may-throw-error%2C-be-sure-to-catch\n        const sendBeacon = WINDOW.navigator.sendBeacon.bind(WINDOW.navigator);\n        sendBeacon(url, serializeEnvelope(envelope));\n      } else {\n        // If beacon is not supported or if they are using the tunnel option\n        // use our regular transport to send client reports to Sentry.\n        this._sendEnvelope(envelope);\n      }\n    } catch (e) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(e);\n    }\n  }\n}\n\nexport { BrowserClient };\n//# sourceMappingURL=client.js.map\n","import { createEnvelope } from './envelope.js';\nimport { dateTimestampInSeconds } from './time.js';\n\n/**\n * Creates client report envelope\n * @param discarded_events An array of discard events\n * @param dsn A DSN that can be set on the header. Optional.\n */\nfunction createClientReportEnvelope(\n  discarded_events,\n  dsn,\n  timestamp,\n) {\n  const clientReportItem = [\n    { type: 'client_report' },\n    {\n      timestamp: timestamp || dateTimestampInSeconds(),\n      discarded_events,\n    },\n  ];\n  return createEnvelope(dsn ? { dsn } : {}, [clientReportItem]);\n}\n\nexport { createClientReportEnvelope };\n//# sourceMappingURL=clientreport.js.map\n","import { createStackParser } from '@sentry/utils';\n\n// global reference to slice\nconst UNKNOWN_FUNCTION = '?';\n\nconst OPERA10_PRIORITY = 10;\nconst OPERA11_PRIORITY = 20;\nconst CHROME_PRIORITY = 30;\nconst WINJS_PRIORITY = 40;\nconst GECKO_PRIORITY = 50;\n\nfunction createFrame(filename, func, lineno, colno) {\n  const frame = {\n    filename,\n    function: func,\n    // All browser frames are considered in_app\n    in_app: true,\n  };\n\n  if (lineno !== undefined) {\n    frame.lineno = lineno;\n  }\n\n  if (colno !== undefined) {\n    frame.colno = colno;\n  }\n\n  return frame;\n}\n\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\nconst chromeRegex =\n  /^\\s*at (?:(.*\\).*?|.*?) ?\\((?:address at )?)?((?:file|https?|blob|chrome-extension|address|native|eval|webpack|<anonymous>|[-a-z]+:|.*bundle|\\/)?.*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\nconst chromeEvalRegex = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n\nconst chrome = line => {\n  const parts = chromeRegex.exec(line);\n\n  if (parts) {\n    const isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n\n    if (isEval) {\n      const subMatch = chromeEvalRegex.exec(parts[2]);\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line/column number\n        parts[2] = subMatch[1]; // url\n        parts[3] = subMatch[2]; // line\n        parts[4] = subMatch[3]; // column\n      }\n    }\n\n    // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now\n    // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)\n    const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);\n\n    return createFrame(filename, func, parts[3] ? +parts[3] : undefined, parts[4] ? +parts[4] : undefined);\n  }\n\n  return;\n};\n\nconst chromeStackLineParser = [CHROME_PRIORITY, chrome];\n\n// gecko regex: `(?:bundle|\\d+\\.js)`: `bundle` is for react native, `\\d+\\.js` also but specifically for ram bundles because it\n// generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js\n// We need this specific case for now because we want no other regex to match.\nconst geckoREgex =\n  /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:file|https?|blob|chrome|webpack|resource|moz-extension|safari-extension|safari-web-extension|capacitor)?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nconst geckoEvalRegex = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\n\nconst gecko = line => {\n  const parts = geckoREgex.exec(line);\n\n  if (parts) {\n    const isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    if (isEval) {\n      const subMatch = geckoEvalRegex.exec(parts[3]);\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line number\n        parts[1] = parts[1] || 'eval';\n        parts[3] = subMatch[1];\n        parts[4] = subMatch[2];\n        parts[5] = ''; // no column when eval\n      }\n    }\n\n    let filename = parts[3];\n    let func = parts[1] || UNKNOWN_FUNCTION;\n    [func, filename] = extractSafariExtensionDetails(func, filename);\n\n    return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined);\n  }\n\n  return;\n};\n\nconst geckoStackLineParser = [GECKO_PRIORITY, gecko];\n\nconst winjsRegex =\n  /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\n\nconst winjs = line => {\n  const parts = winjsRegex.exec(line);\n\n  return parts\n    ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined)\n    : undefined;\n};\n\nconst winjsStackLineParser = [WINJS_PRIORITY, winjs];\n\nconst opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n\nconst opera10 = line => {\n  const parts = opera10Regex.exec(line);\n  return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;\n};\n\nconst opera10StackLineParser = [OPERA10_PRIORITY, opera10];\n\nconst opera11Regex =\n  / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\(.*\\))? in (.*):\\s*$/i;\n\nconst opera11 = line => {\n  const parts = opera11Regex.exec(line);\n  return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined;\n};\n\nconst opera11StackLineParser = [OPERA11_PRIORITY, opera11];\n\nconst defaultStackLineParsers = [chromeStackLineParser, geckoStackLineParser, winjsStackLineParser];\n\nconst defaultStackParser = createStackParser(...defaultStackLineParsers);\n\n/**\n * Safari web extensions, starting version unknown, can produce \"frames-only\" stacktraces.\n * What it means, is that instead of format like:\n *\n * Error: wat\n *   at function@url:row:col\n *   at function@url:row:col\n *   at function@url:row:col\n *\n * it produces something like:\n *\n *   function@url:row:col\n *   function@url:row:col\n *   function@url:row:col\n *\n * Because of that, it won't be captured by `chrome` RegExp and will fall into `Gecko` branch.\n * This function is extracted so that we can use it in both places without duplicating the logic.\n * Unfortunately \"just\" changing RegExp is too complicated now and making it pass all tests\n * and fix this case seems like an impossible, or at least way too time-consuming task.\n */\nconst extractSafariExtensionDetails = (func, filename) => {\n  const isSafariExtension = func.indexOf('safari-extension') !== -1;\n  const isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;\n\n  return isSafariExtension || isSafariWebExtension\n    ? [\n        func.indexOf('@') !== -1 ? func.split('@')[0] : UNKNOWN_FUNCTION,\n        isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`,\n      ]\n    : [func, filename];\n};\n\nexport { chromeStackLineParser, defaultStackLineParsers, defaultStackParser, geckoStackLineParser, opera10StackLineParser, opera11StackLineParser, winjsStackLineParser };\n//# sourceMappingURL=stack-parsers.js.map\n","import { fill, getFunctionName, getOriginalFunction } from '@sentry/utils';\nimport { WINDOW, wrap } from '../helpers.js';\n\nconst DEFAULT_EVENT_TARGET = [\n  'EventTarget',\n  'Window',\n  'Node',\n  'ApplicationCache',\n  'AudioTrackList',\n  'ChannelMergerNode',\n  'CryptoOperation',\n  'EventSource',\n  'FileReader',\n  'HTMLUnknownElement',\n  'IDBDatabase',\n  'IDBRequest',\n  'IDBTransaction',\n  'KeyOperation',\n  'MediaController',\n  'MessagePort',\n  'ModalWindow',\n  'Notification',\n  'SVGElementInstance',\n  'Screen',\n  'TextTrack',\n  'TextTrackCue',\n  'TextTrackList',\n  'WebSocket',\n  'WebSocketWorker',\n  'Worker',\n  'XMLHttpRequest',\n  'XMLHttpRequestEventTarget',\n  'XMLHttpRequestUpload',\n];\n\n/** Wrap timer functions and event targets to catch errors and provide better meta data */\nclass TryCatch  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'TryCatch';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = TryCatch.id;}\n\n  /** JSDoc */\n\n  /**\n   * @inheritDoc\n   */\n   constructor(options) {;TryCatch.prototype.__init.call(this);\n    this._options = {\n      XMLHttpRequest: true,\n      eventTarget: true,\n      requestAnimationFrame: true,\n      setInterval: true,\n      setTimeout: true,\n      ...options,\n    };\n  }\n\n  /**\n   * Wrap timer functions and event targets to catch errors\n   * and provide better metadata.\n   */\n   setupOnce() {\n    if (this._options.setTimeout) {\n      fill(WINDOW, 'setTimeout', _wrapTimeFunction);\n    }\n\n    if (this._options.setInterval) {\n      fill(WINDOW, 'setInterval', _wrapTimeFunction);\n    }\n\n    if (this._options.requestAnimationFrame) {\n      fill(WINDOW, 'requestAnimationFrame', _wrapRAF);\n    }\n\n    if (this._options.XMLHttpRequest && 'XMLHttpRequest' in WINDOW) {\n      fill(XMLHttpRequest.prototype, 'send', _wrapXHR);\n    }\n\n    const eventTargetOption = this._options.eventTarget;\n    if (eventTargetOption) {\n      const eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;\n      eventTarget.forEach(_wrapEventTarget);\n    }\n  }\n} TryCatch.__initStatic();\n\n/** JSDoc */\nfunction _wrapTimeFunction(original) {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function ( ...args) {\n    const originalCallback = args[0];\n    args[0] = wrap(originalCallback, {\n      mechanism: {\n        data: { function: getFunctionName(original) },\n        handled: true,\n        type: 'instrument',\n      },\n    });\n    return original.apply(this, args);\n  };\n}\n\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _wrapRAF(original) {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function ( callback) {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return original.apply(this, [\n      wrap(callback, {\n        mechanism: {\n          data: {\n            function: 'requestAnimationFrame',\n            handler: getFunctionName(original),\n          },\n          handled: true,\n          type: 'instrument',\n        },\n      }),\n    ]);\n  };\n}\n\n/** JSDoc */\nfunction _wrapXHR(originalSend) {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function ( ...args) {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const xhr = this;\n    const xmlHttpRequestProps = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n\n    xmlHttpRequestProps.forEach(prop => {\n      if (prop in xhr && typeof xhr[prop] === 'function') {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        fill(xhr, prop, function (original) {\n          const wrapOptions = {\n            mechanism: {\n              data: {\n                function: prop,\n                handler: getFunctionName(original),\n              },\n              handled: true,\n              type: 'instrument',\n            },\n          };\n\n          // If Instrument integration has been called before TryCatch, get the name of original function\n          const originalFunction = getOriginalFunction(original);\n          if (originalFunction) {\n            wrapOptions.mechanism.data.handler = getFunctionName(originalFunction);\n          }\n\n          // Otherwise wrap directly\n          return wrap(original, wrapOptions);\n        });\n      }\n    });\n\n    return originalSend.apply(this, args);\n  };\n}\n\n/** JSDoc */\nfunction _wrapEventTarget(target) {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const globalObject = WINDOW ;\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  const proto = globalObject[target] && globalObject[target].prototype;\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins\n  if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n    return;\n  }\n\n  fill(proto, 'addEventListener', function (original)\n\n {\n    return function (\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n      eventName,\n      fn,\n      options,\n    ) {\n      try {\n        if (typeof fn.handleEvent === 'function') {\n          // ESlint disable explanation:\n          //  First, it is generally safe to call `wrap` with an unbound function. Furthermore, using `.bind()` would\n          //  introduce a bug here, because bind returns a new function that doesn't have our\n          //  flags(like __sentry_original__) attached. `wrap` checks for those flags to avoid unnecessary wrapping.\n          //  Without those flags, every call to addEventListener wraps the function again, causing a memory leak.\n          // eslint-disable-next-line @typescript-eslint/unbound-method\n          fn.handleEvent = wrap(fn.handleEvent, {\n            mechanism: {\n              data: {\n                function: 'handleEvent',\n                handler: getFunctionName(fn),\n                target,\n              },\n              handled: true,\n              type: 'instrument',\n            },\n          });\n        }\n      } catch (err) {\n        // can sometimes get 'Permission denied to access property \"handle Event'\n      }\n\n      return original.apply(this, [\n        eventName,\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        wrap(fn , {\n          mechanism: {\n            data: {\n              function: 'addEventListener',\n              handler: getFunctionName(fn),\n              target,\n            },\n            handled: true,\n            type: 'instrument',\n          },\n        }),\n        options,\n      ]);\n    };\n  });\n\n  fill(\n    proto,\n    'removeEventListener',\n    function (\n      originalRemoveEventListener,\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ) {\n      return function (\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n        eventName,\n        fn,\n        options,\n      ) {\n        /**\n         * There are 2 possible scenarios here:\n         *\n         * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified\n         * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function\n         * as a pass-through, and call original `removeEventListener` with it.\n         *\n         * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using\n         * our wrapped version of `addEventListener`, which internally calls `wrap` helper.\n         * This helper \"wraps\" whole callback inside a try/catch statement, and attached appropriate metadata to it,\n         * in order for us to make a distinction between wrapped/non-wrapped functions possible.\n         * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.\n         *\n         * When someone adds a handler prior to initialization, and then do it again, but after,\n         * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible\n         * to get rid of the initial handler and it'd stick there forever.\n         */\n        const wrappedEventHandler = fn ;\n        try {\n          const originalEventHandler = wrappedEventHandler && wrappedEventHandler.__sentry_wrapped__;\n          if (originalEventHandler) {\n            originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\n          }\n        } catch (e) {\n          // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n        }\n        return originalRemoveEventListener.call(this, eventName, wrappedEventHandler, options);\n      };\n    },\n  );\n}\n\nexport { TryCatch };\n//# sourceMappingURL=trycatch.js.map\n","import { getCurrentHub } from '@sentry/core';\nimport { addInstrumentationHandler, isString, isPrimitive, isErrorEvent, getLocationHref, logger, addExceptionMechanism } from '@sentry/utils';\nimport { eventFromUnknownInput } from '../eventbuilder.js';\nimport { shouldIgnoreOnError } from '../helpers.js';\n\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n\n/** Global handlers */\nclass GlobalHandlers  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'GlobalHandlers';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = GlobalHandlers.id;}\n\n  /** JSDoc */\n\n  /**\n   * Stores references functions to installing handlers. Will set to undefined\n   * after they have been run so that they are not used twice.\n   */\n   __init2() {this._installFunc = {\n    onerror: _installGlobalOnErrorHandler,\n    onunhandledrejection: _installGlobalOnUnhandledRejectionHandler,\n  };}\n\n  /** JSDoc */\n   constructor(options) {;GlobalHandlers.prototype.__init.call(this);GlobalHandlers.prototype.__init2.call(this);\n    this._options = {\n      onerror: true,\n      onunhandledrejection: true,\n      ...options,\n    };\n  }\n  /**\n   * @inheritDoc\n   */\n   setupOnce() {\n    Error.stackTraceLimit = 50;\n    const options = this._options;\n\n    // We can disable guard-for-in as we construct the options object above + do checks against\n    // `this._installFunc` for the property.\n    // eslint-disable-next-line guard-for-in\n    for (const key in options) {\n      const installFunc = this._installFunc[key ];\n      if (installFunc && options[key ]) {\n        globalHandlerLog(key);\n        installFunc();\n        this._installFunc[key ] = undefined;\n      }\n    }\n  }\n} GlobalHandlers.__initStatic();\n\n/** JSDoc */\nfunction _installGlobalOnErrorHandler() {\n  addInstrumentationHandler(\n    'error',\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (data) => {\n      const [hub, stackParser, attachStacktrace] = getHubAndOptions();\n      if (!hub.getIntegration(GlobalHandlers)) {\n        return;\n      }\n      const { msg, url, line, column, error } = data;\n      if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {\n        return;\n      }\n\n      const event =\n        error === undefined && isString(msg)\n          ? _eventFromIncompleteOnError(msg, url, line, column)\n          : _enhanceEventWithInitialFrame(\n              eventFromUnknownInput(stackParser, error || msg, undefined, attachStacktrace, false),\n              url,\n              line,\n              column,\n            );\n\n      event.level = 'error';\n\n      addMechanismAndCapture(hub, error, event, 'onerror');\n    },\n  );\n}\n\n/** JSDoc */\nfunction _installGlobalOnUnhandledRejectionHandler() {\n  addInstrumentationHandler(\n    'unhandledrejection',\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    (e) => {\n      const [hub, stackParser, attachStacktrace] = getHubAndOptions();\n      if (!hub.getIntegration(GlobalHandlers)) {\n        return;\n      }\n      let error = e;\n\n      // dig the object of the rejection out of known event types\n      try {\n        // PromiseRejectionEvents store the object of the rejection under 'reason'\n        // see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent\n        if ('reason' in e) {\n          error = e.reason;\n        }\n        // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents\n        // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into\n        // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec\n        // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and\n        // https://github.com/getsentry/sentry-javascript/issues/2380\n        else if ('detail' in e && 'reason' in e.detail) {\n          error = e.detail.reason;\n        }\n      } catch (_oO) {\n        // no-empty\n      }\n\n      if (shouldIgnoreOnError() || (error && error.__sentry_own_request__)) {\n        return true;\n      }\n\n      const event = isPrimitive(error)\n        ? _eventFromRejectionWithPrimitive(error)\n        : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, true);\n\n      event.level = 'error';\n\n      addMechanismAndCapture(hub, error, event, 'onunhandledrejection');\n      return;\n    },\n  );\n}\n\n/**\n * Create an event from a promise rejection where the `reason` is a primitive.\n *\n * @param reason: The `reason` property of the promise rejection\n * @returns An Event object with an appropriate `exception` value\n */\nfunction _eventFromRejectionWithPrimitive(reason) {\n  return {\n    exception: {\n      values: [\n        {\n          type: 'UnhandledRejection',\n          // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)\n          value: `Non-Error promise rejection captured with value: ${String(reason)}`,\n        },\n      ],\n    },\n  };\n}\n\n/**\n * This function creates a stack from an old, error-less onerror handler.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _eventFromIncompleteOnError(msg, url, line, column) {\n  const ERROR_TYPES_RE =\n    /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;\n\n  // If 'message' is ErrorEvent, get real message from inside\n  let message = isErrorEvent(msg) ? msg.message : msg;\n  let name = 'Error';\n\n  const groups = message.match(ERROR_TYPES_RE);\n  if (groups) {\n    name = groups[1];\n    message = groups[2];\n  }\n\n  const event = {\n    exception: {\n      values: [\n        {\n          type: name,\n          value: message,\n        },\n      ],\n    },\n  };\n\n  return _enhanceEventWithInitialFrame(event, url, line, column);\n}\n\n/** JSDoc */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _enhanceEventWithInitialFrame(event, url, line, column) {\n  // event.exception\n  const e = (event.exception = event.exception || {});\n  // event.exception.values\n  const ev = (e.values = e.values || []);\n  // event.exception.values[0]\n  const ev0 = (ev[0] = ev[0] || {});\n  // event.exception.values[0].stacktrace\n  const ev0s = (ev0.stacktrace = ev0.stacktrace || {});\n  // event.exception.values[0].stacktrace.frames\n  const ev0sf = (ev0s.frames = ev0s.frames || []);\n\n  const colno = isNaN(parseInt(column, 10)) ? undefined : column;\n  const lineno = isNaN(parseInt(line, 10)) ? undefined : line;\n  const filename = isString(url) && url.length > 0 ? url : getLocationHref();\n\n  // event.exception.values[0].stacktrace.frames\n  if (ev0sf.length === 0) {\n    ev0sf.push({\n      colno,\n      filename,\n      function: '?',\n      in_app: true,\n      lineno,\n    });\n  }\n\n  return event;\n}\n\nfunction globalHandlerLog(type) {\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Global Handler attached: ${type}`);\n}\n\nfunction addMechanismAndCapture(hub, error, event, type) {\n  addExceptionMechanism(event, {\n    handled: false,\n    type,\n  });\n  hub.captureEvent(event, {\n    originalException: error,\n  });\n}\n\nfunction getHubAndOptions() {\n  const hub = getCurrentHub();\n  const client = hub.getClient();\n  const options = (client && client.getOptions()) || {\n    stackParser: () => [],\n    attachStacktrace: false,\n  };\n  return [hub, options.stackParser, options.attachStacktrace];\n}\n\nexport { GlobalHandlers };\n//# sourceMappingURL=globalhandlers.js.map\n","import { getCurrentHub, addGlobalEventProcessor } from '@sentry/core';\nimport { isInstanceOf } from '@sentry/utils';\nimport { exceptionFromError } from '../eventbuilder.js';\n\nconst DEFAULT_KEY = 'cause';\nconst DEFAULT_LIMIT = 5;\n\n/** Adds SDK info to an event. */\nclass LinkedErrors  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'LinkedErrors';}\n\n  /**\n   * @inheritDoc\n   */\n    __init() {this.name = LinkedErrors.id;}\n\n  /**\n   * @inheritDoc\n   */\n\n  /**\n   * @inheritDoc\n   */\n\n  /**\n   * @inheritDoc\n   */\n   constructor(options = {}) {;LinkedErrors.prototype.__init.call(this);\n    this._key = options.key || DEFAULT_KEY;\n    this._limit = options.limit || DEFAULT_LIMIT;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce() {\n    const client = getCurrentHub().getClient();\n    if (!client) {\n      return;\n    }\n    addGlobalEventProcessor((event, hint) => {\n      const self = getCurrentHub().getIntegration(LinkedErrors);\n      return self ? _handler(client.getOptions().stackParser, self._key, self._limit, event, hint) : event;\n    });\n  }\n} LinkedErrors.__initStatic();\n\n/**\n * @inheritDoc\n */\nfunction _handler(\n  parser,\n  key,\n  limit,\n  event,\n  hint,\n) {\n  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n    return event;\n  }\n  const linkedErrors = _walkErrorTree(parser, limit, hint.originalException , key);\n  event.exception.values = [...linkedErrors, ...event.exception.values];\n  return event;\n}\n\n/**\n * JSDOC\n */\nfunction _walkErrorTree(\n  parser,\n  limit,\n  error,\n  key,\n  stack = [],\n) {\n  if (!isInstanceOf(error[key], Error) || stack.length + 1 >= limit) {\n    return stack;\n  }\n  const exception = exceptionFromError(parser, error[key]);\n  return _walkErrorTree(parser, limit, error[key], key, [exception, ...stack]);\n}\n\nexport { LinkedErrors, _handler, _walkErrorTree };\n//# sourceMappingURL=linkederrors.js.map\n","import { logger } from '@sentry/utils';\n\n/** Deduplication filter */\nclass Dedupe  {constructor() { Dedupe.prototype.__init.call(this); }\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'Dedupe';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = Dedupe.id;}\n\n  /**\n   * @inheritDoc\n   */\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce(addGlobalEventProcessor, getCurrentHub) {\n    const eventProcessor = currentEvent => {\n      const self = getCurrentHub().getIntegration(Dedupe);\n      if (self) {\n        // Juuust in case something goes wrong\n        try {\n          if (_shouldDropEvent(currentEvent, self._previousEvent)) {\n            (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Event dropped due to being a duplicate of previously captured event.');\n            return null;\n          }\n        } catch (_oO) {\n          return (self._previousEvent = currentEvent);\n        }\n\n        return (self._previousEvent = currentEvent);\n      }\n      return currentEvent;\n    };\n\n    eventProcessor.id = this.name;\n    addGlobalEventProcessor(eventProcessor);\n  }\n} Dedupe.__initStatic();\n\n/** JSDoc */\nfunction _shouldDropEvent(currentEvent, previousEvent) {\n  if (!previousEvent) {\n    return false;\n  }\n\n  if (_isSameMessageEvent(currentEvent, previousEvent)) {\n    return true;\n  }\n\n  if (_isSameExceptionEvent(currentEvent, previousEvent)) {\n    return true;\n  }\n\n  return false;\n}\n\n/** JSDoc */\nfunction _isSameMessageEvent(currentEvent, previousEvent) {\n  const currentMessage = currentEvent.message;\n  const previousMessage = previousEvent.message;\n\n  // If neither event has a message property, they were both exceptions, so bail out\n  if (!currentMessage && !previousMessage) {\n    return false;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {\n    return false;\n  }\n\n  if (currentMessage !== previousMessage) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameExceptionEvent(currentEvent, previousEvent) {\n  const previousException = _getExceptionFromEvent(previousEvent);\n  const currentException = _getExceptionFromEvent(currentEvent);\n\n  if (!previousException || !currentException) {\n    return false;\n  }\n\n  if (previousException.type !== currentException.type || previousException.value !== currentException.value) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameStacktrace(currentEvent, previousEvent) {\n  let currentFrames = _getFramesFromEvent(currentEvent);\n  let previousFrames = _getFramesFromEvent(previousEvent);\n\n  // If neither event has a stacktrace, they are assumed to be the same\n  if (!currentFrames && !previousFrames) {\n    return true;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {\n    return false;\n  }\n\n  currentFrames = currentFrames ;\n  previousFrames = previousFrames ;\n\n  // If number of frames differ, they are not the same\n  if (previousFrames.length !== currentFrames.length) {\n    return false;\n  }\n\n  // Otherwise, compare the two\n  for (let i = 0; i < previousFrames.length; i++) {\n    const frameA = previousFrames[i];\n    const frameB = currentFrames[i];\n\n    if (\n      frameA.filename !== frameB.filename ||\n      frameA.lineno !== frameB.lineno ||\n      frameA.colno !== frameB.colno ||\n      frameA.function !== frameB.function\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/** JSDoc */\nfunction _isSameFingerprint(currentEvent, previousEvent) {\n  let currentFingerprint = currentEvent.fingerprint;\n  let previousFingerprint = previousEvent.fingerprint;\n\n  // If neither event has a fingerprint, they are assumed to be the same\n  if (!currentFingerprint && !previousFingerprint) {\n    return true;\n  }\n\n  // If only one event has a fingerprint, but not the other one, they are not the same\n  if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {\n    return false;\n  }\n\n  currentFingerprint = currentFingerprint ;\n  previousFingerprint = previousFingerprint ;\n\n  // Otherwise, compare the two\n  try {\n    return !!(currentFingerprint.join('') === previousFingerprint.join(''));\n  } catch (_oO) {\n    return false;\n  }\n}\n\n/** JSDoc */\nfunction _getExceptionFromEvent(event) {\n  return event.exception && event.exception.values && event.exception.values[0];\n}\n\n/** JSDoc */\nfunction _getFramesFromEvent(event) {\n  const exception = event.exception;\n\n  if (exception) {\n    try {\n      // @ts-ignore Object could be undefined\n      return exception.values[0].stacktrace.frames;\n    } catch (_oO) {\n      return undefined;\n    }\n  }\n  return undefined;\n}\n\nexport { Dedupe };\n//# sourceMappingURL=dedupe.js.map\n","import { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { WINDOW } from '../helpers.js';\n\n/** HttpContext integration collects information about HTTP request headers */\nclass HttpContext  {constructor() { HttpContext.prototype.__init.call(this); }\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'HttpContext';}\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = HttpContext.id;}\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce() {\n    addGlobalEventProcessor((event) => {\n      if (getCurrentHub().getIntegration(HttpContext)) {\n        // if none of the information we want exists, don't bother\n        if (!WINDOW.navigator && !WINDOW.location && !WINDOW.document) {\n          return event;\n        }\n\n        // grab as much info as exists and add it to the event\n        const url = (event.request && event.request.url) || (WINDOW.location && WINDOW.location.href);\n        const { referrer } = WINDOW.document || {};\n        const { userAgent } = WINDOW.navigator || {};\n\n        const headers = {\n          ...(event.request && event.request.headers),\n          ...(referrer && { Referer: referrer }),\n          ...(userAgent && { 'User-Agent': userAgent }),\n        };\n        const request = { ...(url && { url }), headers };\n\n        return { ...event, request };\n      }\n      return event;\n    });\n  }\n} HttpContext.__initStatic();\n\nexport { HttpContext };\n//# sourceMappingURL=httpcontext.js.map\n","import { SentryError } from './error.js';\nimport { rejectedSyncPromise, SyncPromise, resolvedSyncPromise } from './syncpromise.js';\n\n/**\n * Creates an new PromiseBuffer object with the specified limit\n * @param limit max number of promises that can be stored in the buffer\n */\nfunction makePromiseBuffer(limit) {\n  const buffer = [];\n\n  function isReady() {\n    return limit === undefined || buffer.length < limit;\n  }\n\n  /**\n   * Remove a promise from the queue.\n   *\n   * @param task Can be any PromiseLike<T>\n   * @returns Removed promise.\n   */\n  function remove(task) {\n    return buffer.splice(buffer.indexOf(task), 1)[0];\n  }\n\n  /**\n   * Add a promise (representing an in-flight action) to the queue, and set it to remove itself on fulfillment.\n   *\n   * @param taskProducer A function producing any PromiseLike<T>; In previous versions this used to be `task:\n   *        PromiseLike<T>`, but under that model, Promises were instantly created on the call-site and their executor\n   *        functions therefore ran immediately. Thus, even if the buffer was full, the action still happened. By\n   *        requiring the promise to be wrapped in a function, we can defer promise creation until after the buffer\n   *        limit check.\n   * @returns The original promise.\n   */\n  function add(taskProducer) {\n    if (!isReady()) {\n      return rejectedSyncPromise(new SentryError('Not adding Promise because buffer limit was reached.'));\n    }\n\n    // start the task and add its promise to the queue\n    const task = taskProducer();\n    if (buffer.indexOf(task) === -1) {\n      buffer.push(task);\n    }\n    void task\n      .then(() => remove(task))\n      // Use `then(null, rejectionHandler)` rather than `catch(rejectionHandler)` so that we can use `PromiseLike`\n      // rather than `Promise`. `PromiseLike` doesn't have a `.catch` method, making its polyfill smaller. (ES5 didn't\n      // have promises, so TS has to polyfill when down-compiling.)\n      .then(null, () =>\n        remove(task).then(null, () => {\n          // We have to add another catch here because `remove()` starts a new promise chain.\n        }),\n      );\n    return task;\n  }\n\n  /**\n   * Wait for all promises in the queue to resolve or for timeout to expire, whichever comes first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the queue is still non-empty. Passing `0` (or\n   * not passing anything) will make the promise wait as long as it takes for the queue to drain before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if the queue is already empty or drains before the timeout, and\n   * `false` otherwise\n   */\n  function drain(timeout) {\n    return new SyncPromise((resolve, reject) => {\n      let counter = buffer.length;\n\n      if (!counter) {\n        return resolve(true);\n      }\n\n      // wait for `timeout` ms and then resolve to `false` (if not cancelled first)\n      const capturedSetTimeout = setTimeout(() => {\n        if (timeout && timeout > 0) {\n          resolve(false);\n        }\n      }, timeout);\n\n      // if all promises resolve in time, cancel the timer and resolve to `true`\n      buffer.forEach(item => {\n        void resolvedSyncPromise(item).then(() => {\n          // eslint-disable-next-line no-plusplus\n          if (!--counter) {\n            clearTimeout(capturedSetTimeout);\n            resolve(true);\n          }\n        }, reject);\n      });\n    });\n  }\n\n  return {\n    $: buffer,\n    add,\n    drain,\n  };\n}\n\nexport { makePromiseBuffer };\n//# sourceMappingURL=promisebuffer.js.map\n","// Intentionally keeping the key broad, as we don't know for sure what rate limit headers get returned from backend\n\nconst DEFAULT_RETRY_AFTER = 60 * 1000; // 60 seconds\n\n/**\n * Extracts Retry-After value from the request header or returns default value\n * @param header string representation of 'Retry-After' header\n * @param now current unix timestamp\n *\n */\nfunction parseRetryAfterHeader(header, now = Date.now()) {\n  const headerDelay = parseInt(`${header}`, 10);\n  if (!isNaN(headerDelay)) {\n    return headerDelay * 1000;\n  }\n\n  const headerDate = Date.parse(`${header}`);\n  if (!isNaN(headerDate)) {\n    return headerDate - now;\n  }\n\n  return DEFAULT_RETRY_AFTER;\n}\n\n/**\n * Gets the time that given category is disabled until for rate limiting\n */\nfunction disabledUntil(limits, category) {\n  return limits[category] || limits.all || 0;\n}\n\n/**\n * Checks if a category is rate limited\n */\nfunction isRateLimited(limits, category, now = Date.now()) {\n  return disabledUntil(limits, category) > now;\n}\n\n/**\n * Update ratelimits from incoming headers.\n * Returns true if headers contains a non-empty rate limiting header.\n */\nfunction updateRateLimits(\n  limits,\n  { statusCode, headers },\n  now = Date.now(),\n) {\n  const updatedRateLimits = {\n    ...limits,\n  };\n\n  // \"The name is case-insensitive.\"\n  // https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n  const rateLimitHeader = headers && headers['x-sentry-rate-limits'];\n  const retryAfterHeader = headers && headers['retry-after'];\n\n  if (rateLimitHeader) {\n    /**\n     * rate limit headers are of the form\n     *     <header>,<header>,..\n     * where each <header> is of the form\n     *     <retry_after>: <categories>: <scope>: <reason_code>\n     * where\n     *     <retry_after> is a delay in seconds\n     *     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form\n     *         <category>;<category>;...\n     *     <scope> is what's being limited (org, project, or key) - ignored by SDK\n     *     <reason_code> is an arbitrary string like \"org_quota\" - ignored by SDK\n     */\n    for (const limit of rateLimitHeader.trim().split(',')) {\n      const [retryAfter, categories] = limit.split(':', 2);\n      const headerDelay = parseInt(retryAfter, 10);\n      const delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n      if (!categories) {\n        updatedRateLimits.all = now + delay;\n      } else {\n        for (const category of categories.split(';')) {\n          updatedRateLimits[category] = now + delay;\n        }\n      }\n    }\n  } else if (retryAfterHeader) {\n    updatedRateLimits.all = now + parseRetryAfterHeader(retryAfterHeader, now);\n  } else if (statusCode === 429) {\n    updatedRateLimits.all = now + 60 * 1000;\n  }\n\n  return updatedRateLimits;\n}\n\nexport { DEFAULT_RETRY_AFTER, disabledUntil, isRateLimited, parseRetryAfterHeader, updateRateLimits };\n//# sourceMappingURL=ratelimit.js.map\n","import { forEachEnvelopeItem, envelopeItemTypeToDataCategory, isRateLimited, resolvedSyncPromise, createEnvelope, serializeEnvelope, logger, updateRateLimits, SentryError, makePromiseBuffer } from '@sentry/utils';\n\nconst DEFAULT_TRANSPORT_BUFFER_SIZE = 30;\n\n/**\n * Creates an instance of a Sentry `Transport`\n *\n * @param options\n * @param makeRequest\n */\nfunction createTransport(\n  options,\n  makeRequest,\n  buffer = makePromiseBuffer(options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE),\n) {\n  let rateLimits = {};\n\n  const flush = (timeout) => buffer.drain(timeout);\n\n  function send(envelope) {\n    const filteredEnvelopeItems = [];\n\n    // Drop rate limited items from envelope\n    forEachEnvelopeItem(envelope, (item, type) => {\n      const envelopeItemDataCategory = envelopeItemTypeToDataCategory(type);\n      if (isRateLimited(rateLimits, envelopeItemDataCategory)) {\n        options.recordDroppedEvent('ratelimit_backoff', envelopeItemDataCategory);\n      } else {\n        filteredEnvelopeItems.push(item);\n      }\n    });\n\n    // Skip sending if envelope is empty after filtering out rate limited events\n    if (filteredEnvelopeItems.length === 0) {\n      return resolvedSyncPromise();\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const filteredEnvelope = createEnvelope(envelope[0], filteredEnvelopeItems );\n\n    // Creates client report for each item in an envelope\n    const recordEnvelopeLoss = (reason) => {\n      forEachEnvelopeItem(filteredEnvelope, (_, type) => {\n        options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type));\n      });\n    };\n\n    const requestTask = () =>\n      makeRequest({ body: serializeEnvelope(filteredEnvelope, options.textEncoder) }).then(\n        response => {\n          // We don't want to throw on NOK responses, but we want to at least log them\n          if (response.statusCode !== undefined && (response.statusCode < 200 || response.statusCode >= 300)) {\n            (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);\n          }\n\n          rateLimits = updateRateLimits(rateLimits, response);\n        },\n        error => {\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Failed while sending event:', error);\n          recordEnvelopeLoss('network_error');\n        },\n      );\n\n    return buffer.add(requestTask).then(\n      result => result,\n      error => {\n        if (error instanceof SentryError) {\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Skipped sending event because buffer is full.');\n          recordEnvelopeLoss('queue_overflow');\n          return resolvedSyncPromise();\n        } else {\n          throw error;\n        }\n      },\n    );\n  }\n\n  return {\n    send,\n    flush,\n  };\n}\n\nexport { DEFAULT_TRANSPORT_BUFFER_SIZE, createTransport };\n//# sourceMappingURL=base.js.map\n","import { isNativeFetch, logger } from '@sentry/utils';\nimport { WINDOW } from '../helpers.js';\n\nlet cachedFetchImpl = undefined;\n\n/**\n * A special usecase for incorrectly wrapped Fetch APIs in conjunction with ad-blockers.\n * Whenever someone wraps the Fetch API and returns the wrong promise chain,\n * this chain becomes orphaned and there is no possible way to capture it's rejections\n * other than allowing it bubble up to this very handler. eg.\n *\n * const f = window.fetch;\n * window.fetch = function () {\n *   const p = f.apply(this, arguments);\n *\n *   p.then(function() {\n *     console.log('hi.');\n *   });\n *\n *   return p;\n * }\n *\n * `p.then(function () { ... })` is producing a completely separate promise chain,\n * however, what's returned is `p` - the result of original `fetch` call.\n *\n * This mean, that whenever we use the Fetch API to send our own requests, _and_\n * some ad-blocker blocks it, this orphaned chain will _always_ reject,\n * effectively causing another event to be captured.\n * This makes a whole process become an infinite loop, which we need to somehow\n * deal with, and break it in one way or another.\n *\n * To deal with this issue, we are making sure that we _always_ use the real\n * browser Fetch API, instead of relying on what `window.fetch` exposes.\n * The only downside to this would be missing our own requests as breadcrumbs,\n * but because we are already not doing this, it should be just fine.\n *\n * Possible failed fetch error messages per-browser:\n *\n * Chrome:  Failed to fetch\n * Edge:    Failed to Fetch\n * Firefox: NetworkError when attempting to fetch resource\n * Safari:  resource blocked by content blocker\n */\nfunction getNativeFetchImplementation() {\n  if (cachedFetchImpl) {\n    return cachedFetchImpl;\n  }\n\n  /* eslint-disable @typescript-eslint/unbound-method */\n\n  // Fast path to avoid DOM I/O\n  if (isNativeFetch(WINDOW.fetch)) {\n    return (cachedFetchImpl = WINDOW.fetch.bind(WINDOW));\n  }\n\n  const document = WINDOW.document;\n  let fetchImpl = WINDOW.fetch;\n  // eslint-disable-next-line deprecation/deprecation\n  if (document && typeof document.createElement === 'function') {\n    try {\n      const sandbox = document.createElement('iframe');\n      sandbox.hidden = true;\n      document.head.appendChild(sandbox);\n      const contentWindow = sandbox.contentWindow;\n      if (contentWindow && contentWindow.fetch) {\n        fetchImpl = contentWindow.fetch;\n      }\n      document.head.removeChild(sandbox);\n    } catch (e) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', e);\n    }\n  }\n\n  return (cachedFetchImpl = fetchImpl.bind(WINDOW));\n  /* eslint-enable @typescript-eslint/unbound-method */\n}\n\n/** Clears cached fetch impl */\nfunction clearCachedFetchImplementation() {\n  cachedFetchImpl = undefined;\n}\n\nexport { clearCachedFetchImplementation, getNativeFetchImplementation };\n//# sourceMappingURL=utils.js.map\n","import { createTransport } from '@sentry/core';\nimport { rejectedSyncPromise } from '@sentry/utils';\nimport { clearCachedFetchImplementation, getNativeFetchImplementation } from './utils.js';\n\n/**\n * Creates a Transport that uses the Fetch API to send events to Sentry.\n */\nfunction makeFetchTransport(\n  options,\n  nativeFetch = getNativeFetchImplementation(),\n) {\n  function makeRequest(request) {\n    const requestOptions = {\n      body: request.body,\n      method: 'POST',\n      referrerPolicy: 'origin',\n      headers: options.headers,\n      // Outgoing requests are usually cancelled when navigating to a different page, causing a \"TypeError: Failed to\n      // fetch\" error and sending a \"network_error\" client-outcome - in Chrome, the request status shows \"(cancelled)\".\n      // The `keepalive` flag keeps outgoing requests alive, even when switching pages. We want this since we're\n      // frequently sending events right before the user is switching pages (eg. whenfinishing navigation transactions).\n      // Gotchas:\n      // - `keepalive` isn't supported by Firefox\n      // - As per spec (https://fetch.spec.whatwg.org/#http-network-or-cache-fetch), a request with `keepalive: true`\n      //   and a content length of > 64 kibibytes returns a network error. We will therefore only activate the flag when\n      //   we're below that limit.\n      keepalive: request.body.length <= 65536,\n      ...options.fetchOptions,\n    };\n\n    try {\n      return nativeFetch(options.url, requestOptions).then(response => ({\n        statusCode: response.status,\n        headers: {\n          'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n          'retry-after': response.headers.get('Retry-After'),\n        },\n      }));\n    } catch (e) {\n      clearCachedFetchImplementation();\n      return rejectedSyncPromise(e);\n    }\n  }\n\n  return createTransport(options, makeRequest);\n}\n\nexport { makeFetchTransport };\n//# sourceMappingURL=fetch.js.map\n","import { createTransport } from '@sentry/core';\nimport { SyncPromise } from '@sentry/utils';\n\n/**\n * The DONE ready state for XmlHttpRequest\n *\n * Defining it here as a constant b/c XMLHttpRequest.DONE is not always defined\n * (e.g. during testing, it is `undefined`)\n *\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/readyState}\n */\nconst XHR_READYSTATE_DONE = 4;\n\n/**\n * Creates a Transport that uses the XMLHttpRequest API to send events to Sentry.\n */\nfunction makeXHRTransport(options) {\n  function makeRequest(request) {\n    return new SyncPromise((resolve, reject) => {\n      const xhr = new XMLHttpRequest();\n\n      xhr.onerror = reject;\n\n      xhr.onreadystatechange = () => {\n        if (xhr.readyState === XHR_READYSTATE_DONE) {\n          resolve({\n            statusCode: xhr.status,\n            headers: {\n              'x-sentry-rate-limits': xhr.getResponseHeader('X-Sentry-Rate-Limits'),\n              'retry-after': xhr.getResponseHeader('Retry-After'),\n            },\n          });\n        }\n      };\n\n      xhr.open('POST', options.url);\n\n      for (const header in options.headers) {\n        if (Object.prototype.hasOwnProperty.call(options.headers, header)) {\n          xhr.setRequestHeader(header, options.headers[header]);\n        }\n      }\n\n      xhr.send(request.body);\n    });\n  }\n\n  return createTransport(options, makeRequest);\n}\n\nexport { makeXHRTransport };\n//# sourceMappingURL=xhr.js.map\n","import { Integrations, getIntegrationsToSetup, initAndBind, getReportDialogEndpoint, getCurrentHub } from '@sentry/core';\nimport { stackParserFromStackParserOptions, supportsFetch, logger, resolvedSyncPromise, addInstrumentationHandler } from '@sentry/utils';\nimport { BrowserClient } from './client.js';\nimport { WINDOW, wrap as wrap$1 } from './helpers.js';\nimport './integrations/index.js';\nimport { defaultStackParser } from './stack-parsers.js';\nimport './transports/index.js';\nimport { TryCatch } from './integrations/trycatch.js';\nimport { Breadcrumbs } from './integrations/breadcrumbs.js';\nimport { GlobalHandlers } from './integrations/globalhandlers.js';\nimport { LinkedErrors } from './integrations/linkederrors.js';\nimport { Dedupe } from './integrations/dedupe.js';\nimport { HttpContext } from './integrations/httpcontext.js';\nimport { makeFetchTransport } from './transports/fetch.js';\nimport { makeXHRTransport } from './transports/xhr.js';\n\nconst defaultIntegrations = [\n  new Integrations.InboundFilters(),\n  new Integrations.FunctionToString(),\n  new TryCatch(),\n  new Breadcrumbs(),\n  new GlobalHandlers(),\n  new LinkedErrors(),\n  new Dedupe(),\n  new HttpContext(),\n];\n\n/**\n * The Sentry Browser SDK Client.\n *\n * To use this SDK, call the {@link init} function as early as possible when\n * loading the web page. To set context information or send manual events, use\n * the provided methods.\n *\n * @example\n *\n * ```\n *\n * import { init } from '@sentry/browser';\n *\n * init({\n *   dsn: '__DSN__',\n *   // ...\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { configureScope } from '@sentry/browser';\n * configureScope((scope: Scope) => {\n *   scope.setExtra({ battery: 0.7 });\n *   scope.setTag({ user_mode: 'admin' });\n *   scope.setUser({ id: '4711' });\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { addBreadcrumb } from '@sentry/browser';\n * addBreadcrumb({\n *   message: 'My Breadcrumb',\n *   // ...\n * });\n * ```\n *\n * @example\n *\n * ```\n *\n * import * as Sentry from '@sentry/browser';\n * Sentry.captureMessage('Hello, world!');\n * Sentry.captureException(new Error('Good bye'));\n * Sentry.captureEvent({\n *   message: 'Manual',\n *   stacktrace: [\n *     // ...\n *   ],\n * });\n * ```\n *\n * @see {@link BrowserOptions} for documentation on configuration options.\n */\nfunction init(options = {}) {\n  if (options.defaultIntegrations === undefined) {\n    options.defaultIntegrations = defaultIntegrations;\n  }\n  if (options.release === undefined) {\n    // This supports the variable that sentry-webpack-plugin injects\n    if (WINDOW.SENTRY_RELEASE && WINDOW.SENTRY_RELEASE.id) {\n      options.release = WINDOW.SENTRY_RELEASE.id;\n    }\n  }\n  if (options.autoSessionTracking === undefined) {\n    options.autoSessionTracking = true;\n  }\n  if (options.sendClientReports === undefined) {\n    options.sendClientReports = true;\n  }\n\n  const clientOptions = {\n    ...options,\n    stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),\n    integrations: getIntegrationsToSetup(options),\n    transport: options.transport || (supportsFetch() ? makeFetchTransport : makeXHRTransport),\n  };\n\n  initAndBind(BrowserClient, clientOptions);\n\n  if (options.autoSessionTracking) {\n    startSessionTracking();\n  }\n}\n\n/**\n * Present the user with a report dialog.\n *\n * @param options Everything is optional, we try to fetch all info need from the global scope.\n */\nfunction showReportDialog(options = {}, hub = getCurrentHub()) {\n  // doesn't work without a document (React Native)\n  if (!WINDOW.document) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Global document not defined in showReportDialog call');\n    return;\n  }\n\n  const { client, scope } = hub.getStackTop();\n  const dsn = options.dsn || (client && client.getDsn());\n  if (!dsn) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('DSN not configured for showReportDialog call');\n    return;\n  }\n\n  if (scope) {\n    options.user = {\n      ...scope.getUser(),\n      ...options.user,\n    };\n  }\n\n  if (!options.eventId) {\n    options.eventId = hub.lastEventId();\n  }\n\n  const script = WINDOW.document.createElement('script');\n  script.async = true;\n  script.src = getReportDialogEndpoint(dsn, options);\n\n  if (options.onLoad) {\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    script.onload = options.onLoad;\n  }\n\n  const injectionPoint = WINDOW.document.head || WINDOW.document.body;\n  if (injectionPoint) {\n    injectionPoint.appendChild(script);\n  } else {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('Not injecting report dialog. No injection point found in HTML');\n  }\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\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nfunction forceLoad() {\n  // Noop\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nfunction onLoad(callback) {\n  callback();\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 */\nfunction 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 resolvedSyncPromise(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 */\nfunction 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 resolvedSyncPromise(false);\n}\n\n/**\n * Wrap code within a try/catch block so the SDK is able to capture errors.\n *\n * @param fn A function to wrap.\n *\n * @returns The result of wrapped function call.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction wrap(fn) {\n  return wrap$1(fn)();\n}\n\nfunction startSessionOnHub(hub) {\n  hub.startSession({ ignoreDuration: true });\n  hub.captureSession();\n}\n\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking() {\n  if (typeof WINDOW.document === 'undefined') {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');\n    return;\n  }\n\n  const hub = getCurrentHub();\n\n  // The only way for this to be false is for there to be a version mismatch between @sentry/browser (>= 6.0.0) and\n  // @sentry/hub (< 5.27.0). In the simple case, there won't ever be such a mismatch, because the two packages are\n  // pinned at the same version in package.json, but there are edge cases where it's possible. See\n  // https://github.com/getsentry/sentry-javascript/issues/3207 and\n  // https://github.com/getsentry/sentry-javascript/issues/3234 and\n  // https://github.com/getsentry/sentry-javascript/issues/3278.\n  if (!hub.captureSession) {\n    return;\n  }\n\n  // The session duration for browser sessions does not track a meaningful\n  // concept that can be used as a metric.\n  // Automatically captured sessions are akin to page views, and thus we\n  // discard their duration.\n  startSessionOnHub(hub);\n\n  // We want to create a session for every navigation as well\n  addInstrumentationHandler('history', ({ from, to }) => {\n    // Don't create an additional session for the initial route or if the location did not change\n    if (!(from === undefined || from === to)) {\n      startSessionOnHub(getCurrentHub());\n    }\n  });\n}\n\nexport { close, defaultIntegrations, flush, forceLoad, init, lastEventId, onLoad, showReportDialog, wrap };\n//# sourceMappingURL=sdk.js.map\n","import { logger } from '@sentry/utils';\nimport { getCurrentHub } from './hub.js';\n\n/** A class object that can instantiate Client objects. */\n\n/**\n * Internal function to create a new SDK client instance. The client is\n * installed and then bound to the current scope.\n *\n * @param clientClass The client class to instantiate.\n * @param options Options to pass to the client.\n */\nfunction initAndBind(\n  clientClass,\n  options,\n) {\n  if (options.debug === true) {\n    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n      logger.enable();\n    } else {\n      // use `console.warn` rather than `logger.warn` since by non-debug bundles have all `logger.x` statements stripped\n      // eslint-disable-next-line no-console\n      console.warn('[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.');\n    }\n  }\n  const hub = getCurrentHub();\n  const scope = hub.getScope();\n  if (scope) {\n    scope.update(options.initialScope);\n  }\n\n  const client = new clientClass(options);\n  hub.bindClient(client);\n}\n\nexport { initAndBind };\n//# sourceMappingURL=sdk.js.map\n","import { SDK_VERSION, init as init$1 } from '@sentry/browser';\n\n/**\n * Inits the React SDK\n */\nfunction init(options) {\n  options._metadata = options._metadata || {};\n  options._metadata.sdk = options._metadata.sdk || {\n    name: 'sentry.javascript.react',\n    packages: [\n      {\n        name: 'npm:@sentry/react',\n        version: SDK_VERSION,\n      },\n    ],\n    version: SDK_VERSION,\n  };\n  init$1(options);\n}\n\nexport { init };\n//# sourceMappingURL=sdk.js.map\n","import { addInstrumentationHandler, logger } from '@sentry/utils';\nimport { getActiveTransaction } from './utils.js';\n\n/**\n * Configures global error listeners\n */\nfunction registerErrorInstrumentation() {\n  addInstrumentationHandler('error', errorCallback);\n  addInstrumentationHandler('unhandledrejection', errorCallback);\n}\n\n/**\n * If an error or unhandled promise occurs, we mark the active transaction as failed\n */\nfunction errorCallback() {\n  const activeTransaction = getActiveTransaction();\n  if (activeTransaction) {\n    const status = 'internal_error';\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] Transaction: ${status} -> Global error occured`);\n    activeTransaction.setStatus(status);\n  }\n}\n\nexport { registerErrorInstrumentation };\n//# sourceMappingURL=errors.js.map\n","import { getMainCarrier } from '@sentry/core';\nimport { logger, isNaN, dynamicRequire, loadModule, isNodeEnv } from '@sentry/utils';\nimport { registerErrorInstrumentation } from './errors.js';\nimport { IdleTransaction } from './idletransaction.js';\nimport { Transaction } from './transaction.js';\nimport { hasTracingEnabled } from './utils.js';\n\n/** Returns all trace headers that are currently on the top scope. */\nfunction traceHeaders() {\n  const scope = this.getScope();\n  if (scope) {\n    const span = scope.getSpan();\n    if (span) {\n      return {\n        'sentry-trace': span.toTraceparent(),\n      };\n    }\n  }\n  return {};\n}\n\n/**\n * Makes a sampling decision for the given transaction and stores it on the transaction.\n *\n * Called every time a transaction is created. Only transactions which emerge with a `sampled` value of `true` will be\n * sent to Sentry.\n *\n * @param transaction: The transaction needing a sampling decision\n * @param options: The current client's options, so we can access `tracesSampleRate` and/or `tracesSampler`\n * @param samplingContext: Default and user-provided data which may be used to help make the decision\n *\n * @returns The given transaction with its `sampled` value set\n */\nfunction sample(\n  transaction,\n  options,\n  samplingContext,\n) {\n  // nothing to do if tracing is not enabled\n  if (!hasTracingEnabled(options)) {\n    transaction.sampled = false;\n    return transaction;\n  }\n\n  // if the user has forced a sampling decision by passing a `sampled` value in their transaction context, go with that\n  if (transaction.sampled !== undefined) {\n    transaction.setMetadata({\n      sampleRate: Number(transaction.sampled),\n    });\n    return transaction;\n  }\n\n  // we would have bailed already if neither `tracesSampler` nor `tracesSampleRate` were defined, so one of these should\n  // work; prefer the hook if so\n  let sampleRate;\n  if (typeof options.tracesSampler === 'function') {\n    sampleRate = options.tracesSampler(samplingContext);\n    transaction.setMetadata({\n      sampleRate: Number(sampleRate),\n    });\n  } else if (samplingContext.parentSampled !== undefined) {\n    sampleRate = samplingContext.parentSampled;\n  } else {\n    sampleRate = options.tracesSampleRate;\n    transaction.setMetadata({\n      sampleRate: Number(sampleRate),\n    });\n  }\n\n  // Since this is coming from the user (or from a function provided by the user), who knows what we might get. (The\n  // only valid values are booleans or numbers between 0 and 1.)\n  if (!isValidSampleRate(sampleRate)) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('[Tracing] Discarding transaction because of invalid sample rate.');\n    transaction.sampled = false;\n    return transaction;\n  }\n\n  // if the function returned 0 (or false), or if `tracesSampleRate` is 0, it's a sign the transaction should be dropped\n  if (!sampleRate) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.log(\n        `[Tracing] Discarding transaction because ${\n          typeof options.tracesSampler === 'function'\n            ? 'tracesSampler returned 0 or false'\n            : 'a negative sampling decision was inherited or tracesSampleRate is set to 0'\n        }`,\n      );\n    transaction.sampled = false;\n    return transaction;\n  }\n\n  // Now we roll the dice. Math.random is inclusive of 0, but not of 1, so strict < is safe here. In case sampleRate is\n  // a boolean, the < comparison will cause it to be automatically cast to 1 if it's true and 0 if it's false.\n  transaction.sampled = Math.random() < (sampleRate );\n\n  // if we're not going to keep it, we're done\n  if (!transaction.sampled) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.log(\n        `[Tracing] Discarding transaction because it's not included in the random sample (sampling rate = ${Number(\n          sampleRate,\n        )})`,\n      );\n    return transaction;\n  }\n\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] starting ${transaction.op} transaction - ${transaction.name}`);\n  return transaction;\n}\n\n/**\n * Checks the given sample rate to make sure it is valid type and value (a boolean, or a number between 0 and 1).\n */\nfunction isValidSampleRate(rate) {\n  // we need to check NaN explicitly because it's of type 'number' and therefore wouldn't get caught by this typecheck\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  if (isNaN(rate) || !(typeof rate === 'number' || typeof rate === 'boolean')) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(\n        `[Tracing] Given sample rate is invalid. Sample rate must be a boolean or a number between 0 and 1. Got ${JSON.stringify(\n          rate,\n        )} of type ${JSON.stringify(typeof rate)}.`,\n      );\n    return false;\n  }\n\n  // in case sampleRate is a boolean, it will get automatically cast to 1 if it's true and 0 if it's false\n  if (rate < 0 || rate > 1) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(`[Tracing] Given sample rate is invalid. Sample rate must be between 0 and 1. Got ${rate}.`);\n    return false;\n  }\n  return true;\n}\n\n/**\n * Creates a new transaction and adds a sampling decision if it doesn't yet have one.\n *\n * The Hub.startTransaction method delegates to this method to do its work, passing the Hub instance in as `this`, as if\n * it had been called on the hub directly. Exists as a separate function so that it can be injected into the class as an\n * \"extension method.\"\n *\n * @param this: The Hub starting the transaction\n * @param transactionContext: Data used to configure the transaction\n * @param CustomSamplingContext: Optional data to be provided to the `tracesSampler` function (if any)\n *\n * @returns The new transaction\n *\n * @see {@link Hub.startTransaction}\n */\nfunction _startTransaction(\n\n  transactionContext,\n  customSamplingContext,\n) {\n  const client = this.getClient();\n  const options = (client && client.getOptions()) || {};\n\n  let transaction = new Transaction(transactionContext, this);\n  transaction = sample(transaction, options, {\n    parentSampled: transactionContext.parentSampled,\n    transactionContext,\n    ...customSamplingContext,\n  });\n  if (transaction.sampled) {\n    transaction.initSpanRecorder(options._experiments && (options._experiments.maxSpans ));\n  }\n  return transaction;\n}\n\n/**\n * Create new idle transaction.\n */\nfunction startIdleTransaction(\n  hub,\n  transactionContext,\n  idleTimeout,\n  finalTimeout,\n  onScope,\n  customSamplingContext,\n  heartbeatInterval,\n) {\n  const client = hub.getClient();\n  const options = (client && client.getOptions()) || {};\n\n  let transaction = new IdleTransaction(transactionContext, hub, idleTimeout, finalTimeout, heartbeatInterval, onScope);\n  transaction = sample(transaction, options, {\n    parentSampled: transactionContext.parentSampled,\n    transactionContext,\n    ...customSamplingContext,\n  });\n  if (transaction.sampled) {\n    transaction.initSpanRecorder(options._experiments && (options._experiments.maxSpans ));\n  }\n  return transaction;\n}\n\n/**\n * @private\n */\nfunction _addTracingExtensions() {\n  const carrier = getMainCarrier();\n  if (!carrier.__SENTRY__) {\n    return;\n  }\n  carrier.__SENTRY__.extensions = carrier.__SENTRY__.extensions || {};\n  if (!carrier.__SENTRY__.extensions.startTransaction) {\n    carrier.__SENTRY__.extensions.startTransaction = _startTransaction;\n  }\n  if (!carrier.__SENTRY__.extensions.traceHeaders) {\n    carrier.__SENTRY__.extensions.traceHeaders = traceHeaders;\n  }\n}\n\n/**\n * @private\n */\nfunction _autoloadDatabaseIntegrations() {\n  const carrier = getMainCarrier();\n  if (!carrier.__SENTRY__) {\n    return;\n  }\n\n  const packageToIntegrationMapping = {\n    mongodb() {\n      const integration = dynamicRequire(module, './integrations/node/mongo')\n\n;\n      return new integration.Mongo();\n    },\n    mongoose() {\n      const integration = dynamicRequire(module, './integrations/node/mongo')\n\n;\n      return new integration.Mongo({ mongoose: true });\n    },\n    mysql() {\n      const integration = dynamicRequire(module, './integrations/node/mysql')\n\n;\n      return new integration.Mysql();\n    },\n    pg() {\n      const integration = dynamicRequire(module, './integrations/node/postgres')\n\n;\n      return new integration.Postgres();\n    },\n  };\n\n  const mappedPackages = Object.keys(packageToIntegrationMapping)\n    .filter(moduleName => !!loadModule(moduleName))\n    .map(pkg => {\n      try {\n        return packageToIntegrationMapping[pkg]();\n      } catch (e) {\n        return undefined;\n      }\n    })\n    .filter(p => p) ;\n\n  if (mappedPackages.length > 0) {\n    carrier.__SENTRY__.integrations = [...(carrier.__SENTRY__.integrations || []), ...mappedPackages];\n  }\n}\n\n/**\n * This patches the global object and injects the Tracing extensions methods\n */\nfunction addExtensionMethods() {\n  _addTracingExtensions();\n\n  // Detect and automatically load specified integrations.\n  if (isNodeEnv()) {\n    _autoloadDatabaseIntegrations();\n  }\n\n  // If an error happens globally, we should make sure transaction status is set to error.\n  registerErrorInstrumentation();\n}\n\nexport { _addTracingExtensions, addExtensionMethods, startIdleTransaction };\n//# sourceMappingURL=hubextensions.js.map\n","import { timestampWithMs, logger } from '@sentry/utils';\nimport { SpanRecorder } from './span.js';\nimport { Transaction } from './transaction.js';\n\nconst DEFAULT_IDLE_TIMEOUT = 1000;\nconst DEFAULT_FINAL_TIMEOUT = 30000;\nconst DEFAULT_HEARTBEAT_INTERVAL = 5000;\n\n/**\n * @inheritDoc\n */\nclass IdleTransactionSpanRecorder extends SpanRecorder {\n   constructor(\n      _pushActivity,\n      _popActivity,\n     transactionSpanId,\n    maxlen,\n  ) {\n    super(maxlen);this._pushActivity = _pushActivity;this._popActivity = _popActivity;this.transactionSpanId = transactionSpanId;;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   add(span) {\n    // We should make sure we do not push and pop activities for\n    // the transaction that this span recorder belongs to.\n    if (span.spanId !== this.transactionSpanId) {\n      // We patch span.finish() to pop an activity after setting an endTimestamp.\n      span.finish = (endTimestamp) => {\n        span.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : timestampWithMs();\n        this._popActivity(span.spanId);\n      };\n\n      // We should only push new activities if the span does not have an end timestamp.\n      if (span.endTimestamp === undefined) {\n        this._pushActivity(span.spanId);\n      }\n    }\n\n    super.add(span);\n  }\n}\n\n/**\n * An IdleTransaction is a transaction that automatically finishes. It does this by tracking child spans as activities.\n * You can have multiple IdleTransactions active, but if the `onScope` option is specified, the idle transaction will\n * put itself on the scope on creation.\n */\nclass IdleTransaction extends Transaction {\n  // Activities store a list of active spans\n   __init() {this.activities = {};}\n\n  // Track state of activities in previous heartbeat\n\n  // Amount of times heartbeat has counted. Will cause transaction to finish after 3 beats.\n   __init2() {this._heartbeatCounter = 0;}\n\n  // We should not use heartbeat if we finished a transaction\n   __init3() {this._finished = false;}\n\n    __init4() {this._beforeFinishCallbacks = [];}\n\n  /**\n   * Timer that tracks Transaction idleTimeout\n   */\n\n   constructor(\n    transactionContext,\n      _idleHub,\n    /**\n     * The time to wait in ms until the idle transaction will be finished. This timer is started each time\n     * there are no active spans on this transaction.\n     */\n      _idleTimeout = DEFAULT_IDLE_TIMEOUT,\n    /**\n     * The final value in ms that a transaction cannot exceed\n     */\n      _finalTimeout = DEFAULT_FINAL_TIMEOUT,\n      _heartbeatInterval = DEFAULT_HEARTBEAT_INTERVAL,\n    // Whether or not the transaction should put itself on the scope when it starts and pop itself off when it ends\n      _onScope = false,\n  ) {\n    super(transactionContext, _idleHub);this._idleHub = _idleHub;this._idleTimeout = _idleTimeout;this._finalTimeout = _finalTimeout;this._heartbeatInterval = _heartbeatInterval;this._onScope = _onScope;IdleTransaction.prototype.__init.call(this);IdleTransaction.prototype.__init2.call(this);IdleTransaction.prototype.__init3.call(this);IdleTransaction.prototype.__init4.call(this);;\n\n    if (_onScope) {\n      // There should only be one active transaction on the scope\n      clearActiveTransaction(_idleHub);\n\n      // We set the transaction here on the scope so error events pick up the trace\n      // context and attach it to the error.\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`Setting idle transaction on scope. Span ID: ${this.spanId}`);\n      _idleHub.configureScope(scope => scope.setSpan(this));\n    }\n\n    this._startIdleTimeout();\n    setTimeout(() => {\n      if (!this._finished) {\n        this.setStatus('deadline_exceeded');\n        this.finish();\n      }\n    }, this._finalTimeout);\n  }\n\n  /** {@inheritDoc} */\n   finish(endTimestamp = timestampWithMs()) {\n    this._finished = true;\n    this.activities = {};\n\n    if (this.spanRecorder) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.log('[Tracing] finishing IdleTransaction', new Date(endTimestamp * 1000).toISOString(), this.op);\n\n      for (const callback of this._beforeFinishCallbacks) {\n        callback(this, endTimestamp);\n      }\n\n      this.spanRecorder.spans = this.spanRecorder.spans.filter((span) => {\n        // If we are dealing with the transaction itself, we just return it\n        if (span.spanId === this.spanId) {\n          return true;\n        }\n\n        // We cancel all pending spans with status \"cancelled\" to indicate the idle transaction was finished early\n        if (!span.endTimestamp) {\n          span.endTimestamp = endTimestamp;\n          span.setStatus('cancelled');\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n            logger.log('[Tracing] cancelling span since transaction ended early', JSON.stringify(span, undefined, 2));\n        }\n\n        const keepSpan = span.startTimestamp < endTimestamp;\n        if (!keepSpan) {\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n            logger.log(\n              '[Tracing] discarding Span since it happened after Transaction was finished',\n              JSON.stringify(span, undefined, 2),\n            );\n        }\n        return keepSpan;\n      });\n\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] flushing IdleTransaction');\n    } else {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] No active IdleTransaction');\n    }\n\n    // if `this._onScope` is `true`, the transaction put itself on the scope when it started\n    if (this._onScope) {\n      clearActiveTransaction(this._idleHub);\n    }\n\n    return super.finish(endTimestamp);\n  }\n\n  /**\n   * Register a callback function that gets excecuted before the transaction finishes.\n   * Useful for cleanup or if you want to add any additional spans based on current context.\n   *\n   * This is exposed because users have no other way of running something before an idle transaction\n   * finishes.\n   */\n   registerBeforeFinishCallback(callback) {\n    this._beforeFinishCallbacks.push(callback);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   initSpanRecorder(maxlen) {\n    if (!this.spanRecorder) {\n      const pushActivity = (id) => {\n        if (this._finished) {\n          return;\n        }\n        this._pushActivity(id);\n      };\n      const popActivity = (id) => {\n        if (this._finished) {\n          return;\n        }\n        this._popActivity(id);\n      };\n\n      this.spanRecorder = new IdleTransactionSpanRecorder(pushActivity, popActivity, this.spanId, maxlen);\n\n      // Start heartbeat so that transactions do not run forever.\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('Starting heartbeat');\n      this._pingHeartbeat();\n    }\n    this.spanRecorder.add(this);\n  }\n\n  /**\n   * Cancels the existing idletimeout, if there is one\n   */\n   _cancelIdleTimeout() {\n    if (this._idleTimeoutID) {\n      clearTimeout(this._idleTimeoutID);\n      this._idleTimeoutID = undefined;\n    }\n  }\n\n  /**\n   * Creates an idletimeout\n   */\n   _startIdleTimeout(endTimestamp) {\n    this._cancelIdleTimeout();\n    this._idleTimeoutID = setTimeout(() => {\n      if (!this._finished && Object.keys(this.activities).length === 0) {\n        this.finish(endTimestamp);\n      }\n    }, this._idleTimeout);\n  }\n\n  /**\n   * Start tracking a specific activity.\n   * @param spanId The span id that represents the activity\n   */\n   _pushActivity(spanId) {\n    this._cancelIdleTimeout();\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] pushActivity: ${spanId}`);\n    this.activities[spanId] = true;\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] new activities count', Object.keys(this.activities).length);\n  }\n\n  /**\n   * Remove an activity from usage\n   * @param spanId The span id that represents the activity\n   */\n   _popActivity(spanId) {\n    if (this.activities[spanId]) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] popActivity ${spanId}`);\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete this.activities[spanId];\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] new activities count', Object.keys(this.activities).length);\n    }\n\n    if (Object.keys(this.activities).length === 0) {\n      // We need to add the timeout here to have the real endtimestamp of the transaction\n      // Remember timestampWithMs is in seconds, timeout is in ms\n      const endTimestamp = timestampWithMs() + this._idleTimeout / 1000;\n      this._startIdleTimeout(endTimestamp);\n    }\n  }\n\n  /**\n   * Checks when entries of this.activities are not changing for 3 beats.\n   * If this occurs we finish the transaction.\n   */\n   _beat() {\n    // We should not be running heartbeat if the idle transaction is finished.\n    if (this._finished) {\n      return;\n    }\n\n    const heartbeatString = Object.keys(this.activities).join('');\n\n    if (heartbeatString === this._prevHeartbeatString) {\n      this._heartbeatCounter += 1;\n    } else {\n      this._heartbeatCounter = 1;\n    }\n\n    this._prevHeartbeatString = heartbeatString;\n\n    if (this._heartbeatCounter >= 3) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] Transaction finished because of no change for 3 heart beats');\n      this.setStatus('deadline_exceeded');\n      this.finish();\n    } else {\n      this._pingHeartbeat();\n    }\n  }\n\n  /**\n   * Pings the heartbeat\n   */\n   _pingHeartbeat() {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`pinging Heartbeat -> current counter: ${this._heartbeatCounter}`);\n    setTimeout(() => {\n      this._beat();\n    }, this._heartbeatInterval);\n  }\n}\n\n/**\n * Reset transaction on scope to `undefined`\n */\nfunction clearActiveTransaction(hub) {\n  const scope = hub.getScope();\n  if (scope) {\n    const transaction = scope.getTransaction();\n    if (transaction) {\n      scope.setSpan(undefined);\n    }\n  }\n}\n\nexport { DEFAULT_FINAL_TIMEOUT, DEFAULT_HEARTBEAT_INTERVAL, DEFAULT_IDLE_TIMEOUT, IdleTransaction, IdleTransactionSpanRecorder };\n//# sourceMappingURL=idletransaction.js.map\n","const TRACEPARENT_REGEXP = new RegExp(\n  '^[ \\\\t]*' + // whitespace\n    '([0-9a-f]{32})?' + // trace_id\n    '-?([0-9a-f]{16})?' + // span_id\n    '-?([01])?' + // sampled\n    '[ \\\\t]*$', // whitespace\n);\n\n/**\n * Extract transaction context data from a `sentry-trace` header.\n *\n * @param traceparent Traceparent string\n *\n * @returns Object containing data from the header, or undefined if traceparent string is malformed\n */\nfunction extractTraceparentData(traceparent) {\n  const matches = traceparent.match(TRACEPARENT_REGEXP);\n\n  if (!traceparent || !matches) {\n    // empty string or no matches is invalid traceparent data\n    return undefined;\n  }\n\n  let parentSampled;\n  if (matches[3] === '1') {\n    parentSampled = true;\n  } else if (matches[3] === '0') {\n    parentSampled = false;\n  }\n\n  return {\n    traceId: matches[1],\n    parentSampled,\n    parentSpanId: matches[2],\n  };\n}\n\nexport { TRACEPARENT_REGEXP, extractTraceparentData };\n//# sourceMappingURL=tracing.js.map\n","import { isString } from './is.js';\nimport { logger } from './logger.js';\n\nconst BAGGAGE_HEADER_NAME = 'baggage';\n\nconst SENTRY_BAGGAGE_KEY_PREFIX = 'sentry-';\n\nconst SENTRY_BAGGAGE_KEY_PREFIX_REGEX = /^sentry-/;\n\n/**\n * Max length of a serialized baggage string\n *\n * https://www.w3.org/TR/baggage/#limits\n */\nconst MAX_BAGGAGE_STRING_LENGTH = 8192;\n\n/**\n * Takes a baggage header and turns it into Dynamic Sampling Context, by extracting all the \"sentry-\" prefixed values\n * from it.\n *\n * @param baggageHeader A very bread definition of a baggage header as it might appear in various frameworks.\n * @returns The Dynamic Sampling Context that was found on `baggageHeader`, if there was any, `undefined` otherwise.\n */\nfunction baggageHeaderToDynamicSamplingContext(\n  // Very liberal definition of what any incoming header might look like\n  baggageHeader,\n) {\n  if (!isString(baggageHeader) && !Array.isArray(baggageHeader)) {\n    return undefined;\n  }\n\n  // Intermediary object to store baggage key value pairs of incoming baggage headers on.\n  // It is later used to read Sentry-DSC-values from.\n  let baggageObject = {};\n\n  if (Array.isArray(baggageHeader)) {\n    // Combine all baggage headers into one object containing the baggage values so we can later read the Sentry-DSC-values from it\n    baggageObject = baggageHeader.reduce((acc, curr) => {\n      const currBaggageObject = baggageHeaderToObject(curr);\n      return {\n        ...acc,\n        ...currBaggageObject,\n      };\n    }, {});\n  } else {\n    // Return undefined if baggage header is an empty string (technically an empty baggage header is not spec conform but\n    // this is how we choose to handle it)\n    if (!baggageHeader) {\n      return undefined;\n    }\n\n    baggageObject = baggageHeaderToObject(baggageHeader);\n  }\n\n  // Read all \"sentry-\" prefixed values out of the baggage object and put it onto a dynamic sampling context object.\n  const dynamicSamplingContext = Object.entries(baggageObject).reduce((acc, [key, value]) => {\n    if (key.match(SENTRY_BAGGAGE_KEY_PREFIX_REGEX)) {\n      const nonPrefixedKey = key.slice(SENTRY_BAGGAGE_KEY_PREFIX.length);\n      acc[nonPrefixedKey] = value;\n    }\n    return acc;\n  }, {});\n\n  // Only return a dynamic sampling context object if there are keys in it.\n  // A keyless object means there were no sentry values on the header, which means that there is no DSC.\n  if (Object.keys(dynamicSamplingContext).length > 0) {\n    return dynamicSamplingContext ;\n  } else {\n    return undefined;\n  }\n}\n\n/**\n * Turns a Dynamic Sampling Object into a baggage header by prefixing all the keys on the object with \"sentry-\".\n *\n * @param dynamicSamplingContext The Dynamic Sampling Context to turn into a header. For convenience and compatibility\n * with the `getDynamicSamplingContext` method on the Transaction class ,this argument can also be `undefined`. If it is\n * `undefined` the function will return `undefined`.\n * @returns a baggage header, created from `dynamicSamplingContext`, or `undefined` either if `dynamicSamplingContext`\n * was `undefined`, or if `dynamicSamplingContext` didn't contain any values.\n */\nfunction dynamicSamplingContextToSentryBaggageHeader(\n  // this also takes undefined for convenience and bundle size in other places\n  dynamicSamplingContext,\n) {\n  // Prefix all DSC keys with \"sentry-\" and put them into a new object\n  const sentryPrefixedDSC = Object.entries(dynamicSamplingContext).reduce(\n    (acc, [dscKey, dscValue]) => {\n      if (dscValue) {\n        acc[`${SENTRY_BAGGAGE_KEY_PREFIX}${dscKey}`] = dscValue;\n      }\n      return acc;\n    },\n    {},\n  );\n\n  return objectToBaggageHeader(sentryPrefixedDSC);\n}\n\n/**\n * Will parse a baggage header, which is a simple key-value map, into a flat object.\n *\n * @param baggageHeader The baggage header to parse.\n * @returns a flat object containing all the key-value pairs from `baggageHeader`.\n */\nfunction baggageHeaderToObject(baggageHeader) {\n  return baggageHeader\n    .split(',')\n    .map(baggageEntry => baggageEntry.split('=').map(keyOrValue => decodeURIComponent(keyOrValue.trim())))\n    .reduce((acc, [key, value]) => {\n      acc[key] = value;\n      return acc;\n    }, {});\n}\n\n/**\n * Turns a flat object (key-value pairs) into a baggage header, which is also just key-value pairs.\n *\n * @param object The object to turn into a baggage header.\n * @returns a baggage header string, or `undefined` if the object didn't have any values, since an empty baggage header\n * is not spec compliant.\n */\nfunction objectToBaggageHeader(object) {\n  if (Object.keys(object).length === 0) {\n    // An empty baggage header is not spec compliant: We return undefined.\n    return undefined;\n  }\n\n  return Object.entries(object).reduce((baggageHeader, [objectKey, objectValue], currentIndex) => {\n    const baggageEntry = `${encodeURIComponent(objectKey)}=${encodeURIComponent(objectValue)}`;\n    const newBaggageHeader = currentIndex === 0 ? baggageEntry : `${baggageHeader},${baggageEntry}`;\n    if (newBaggageHeader.length > MAX_BAGGAGE_STRING_LENGTH) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn(\n          `Not adding key: ${objectKey} with val: ${objectValue} to baggage header due to exceeding baggage size limits.`,\n        );\n      return baggageHeader;\n    } else {\n      return newBaggageHeader;\n    }\n  }, '');\n}\n\nexport { BAGGAGE_HEADER_NAME, MAX_BAGGAGE_STRING_LENGTH, SENTRY_BAGGAGE_KEY_PREFIX, SENTRY_BAGGAGE_KEY_PREFIX_REGEX, baggageHeaderToDynamicSamplingContext, dynamicSamplingContextToSentryBaggageHeader };\n//# sourceMappingURL=baggage.js.map\n","import { GLOBAL_OBJ } from '@sentry/utils';\n\nconst WINDOW = GLOBAL_OBJ ;\n\nexport { WINDOW };\n//# sourceMappingURL=types.js.map\n","const bindReporter = (\n  callback,\n  metric,\n  reportAllChanges,\n) => {\n  let prevValue;\n  let delta;\n  return (forceReport) => {\n    if (metric.value >= 0) {\n      if (forceReport || reportAllChanges) {\n        delta = metric.value - (prevValue || 0);\n\n        // Report the metric if there's a non-zero delta or if no previous\n        // value exists (which can happen in the case of the document becoming\n        // hidden when the metric value is 0).\n        // See: https://github.com/GoogleChrome/web-vitals/issues/14\n        if (delta || prevValue === undefined) {\n          prevValue = metric.value;\n          metric.delta = delta;\n          callback(metric);\n        }\n      }\n    }\n  };\n};\n\nexport { bindReporter };\n//# sourceMappingURL=bindReporter.js.map\n","import { WINDOW } from '../../types.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst getNavigationEntryFromPerformanceTiming = () => {\n  // eslint-disable-next-line deprecation/deprecation\n  const timing = WINDOW.performance.timing;\n  // eslint-disable-next-line deprecation/deprecation\n  const type = WINDOW.performance.navigation.type;\n\n  const navigationEntry = {\n    entryType: 'navigation',\n    startTime: 0,\n    type: type == 2 ? 'back_forward' : type === 1 ? 'reload' : 'navigate',\n  };\n\n  for (const key in timing) {\n    if (key !== 'navigationStart' && key !== 'toJSON') {\n      navigationEntry[key] = Math.max((timing[key ] ) - timing.navigationStart, 0);\n    }\n  }\n  return navigationEntry ;\n};\n\nconst getNavigationEntry = () => {\n  if (WINDOW.__WEB_VITALS_POLYFILL__) {\n    return (\n      WINDOW.performance &&\n      ((performance.getEntriesByType && performance.getEntriesByType('navigation')[0]) ||\n        getNavigationEntryFromPerformanceTiming())\n    );\n  } else {\n    return WINDOW.performance && performance.getEntriesByType && performance.getEntriesByType('navigation')[0];\n  }\n};\n\nexport { getNavigationEntry };\n//# sourceMappingURL=getNavigationEntry.js.map\n","import { getNavigationEntry } from './getNavigationEntry.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst getActivationStart = () => {\n  const navEntry = getNavigationEntry();\n  return (navEntry && navEntry.activationStart) || 0;\n};\n\nexport { getActivationStart };\n//# sourceMappingURL=getActivationStart.js.map\n","import { WINDOW } from '../../types.js';\nimport { generateUniqueID } from './generateUniqueID.js';\nimport { getActivationStart } from './getActivationStart.js';\nimport { getNavigationEntry } from './getNavigationEntry.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst initMetric = (name, value) => {\n  const navEntry = getNavigationEntry();\n  let navigationType = 'navigate';\n\n  if (navEntry) {\n    if (WINDOW.document.prerendering || getActivationStart() > 0) {\n      navigationType = 'prerender';\n    } else {\n      navigationType = navEntry.type.replace(/_/g, '-') ;\n    }\n  }\n\n  return {\n    name,\n    value: typeof value === 'undefined' ? -1 : value,\n    rating: 'good', // Will be updated if the value changes.\n    delta: 0,\n    entries: [],\n    id: generateUniqueID(),\n    navigationType,\n  };\n};\n\nexport { initMetric };\n//# sourceMappingURL=initMetric.js.map\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Performantly generate a unique, 30-char string by combining a version\n * number, the current timestamp with a 13-digit number integer.\n * @return {string}\n */\nconst generateUniqueID = () => {\n  return `v3-${Date.now()}-${Math.floor(Math.random() * (9e12 - 1)) + 1e12}`;\n};\n\nexport { generateUniqueID };\n//# sourceMappingURL=generateUniqueID.js.map\n","/**\n * Takes a performance entry type and a callback function, and creates a\n * `PerformanceObserver` instance that will observe the specified entry type\n * with buffering enabled and call the callback _for each entry_.\n *\n * This function also feature-detects entry support and wraps the logic in a\n * try/catch to avoid errors in unsupporting browsers.\n */\nconst observe = (\n  type,\n  callback,\n  opts,\n) => {\n  try {\n    if (PerformanceObserver.supportedEntryTypes.includes(type)) {\n      const po = new PerformanceObserver(list => {\n        callback(list.getEntries() );\n      });\n      po.observe(\n        Object.assign(\n          {\n            type,\n            buffered: true,\n          },\n          opts || {},\n        ) ,\n      );\n      return po;\n    }\n  } catch (e) {\n    // Do nothing.\n  }\n  return;\n};\n\nexport { observe };\n//# sourceMappingURL=observe.js.map\n","import { WINDOW } from '../../types.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst onHidden = (cb, once) => {\n  const onHiddenOrPageHide = (event) => {\n    if (event.type === 'pagehide' || WINDOW.document.visibilityState === 'hidden') {\n      cb(event);\n      if (once) {\n        removeEventListener('visibilitychange', onHiddenOrPageHide, true);\n        removeEventListener('pagehide', onHiddenOrPageHide, true);\n      }\n    }\n  };\n  addEventListener('visibilitychange', onHiddenOrPageHide, true);\n  // Some browsers have buggy implementations of visibilitychange,\n  // so we use pagehide in addition, just to be safe.\n  addEventListener('pagehide', onHiddenOrPageHide, true);\n};\n\nexport { onHidden };\n//# sourceMappingURL=onHidden.js.map\n","import { WINDOW } from '../../types.js';\nimport { onHidden } from './onHidden.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nlet firstHiddenTime = -1;\n\nconst initHiddenTime = () => {\n  // If the document is hidden and not prerendering, assume it was always\n  // hidden and the page was loaded in the background.\n  return WINDOW.document.visibilityState === 'hidden' && !WINDOW.document.prerendering ? 0 : Infinity;\n};\n\nconst trackChanges = () => {\n  // Update the time if/when the document becomes hidden.\n  onHidden(({ timeStamp }) => {\n    firstHiddenTime = timeStamp;\n  }, true);\n};\n\nconst getVisibilityWatcher = (\n\n) => {\n  if (firstHiddenTime < 0) {\n    // If the document is hidden when this code runs, assume it was hidden\n    // since navigation start. This isn't a perfect heuristic, but it's the\n    // best we can do until an API is available to support querying past\n    // visibilityState.\n    firstHiddenTime = initHiddenTime();\n    trackChanges();\n  }\n  return {\n    get firstHiddenTime() {\n      return firstHiddenTime;\n    },\n  };\n};\n\nexport { getVisibilityWatcher };\n//# sourceMappingURL=getVisibilityWatcher.js.map\n","import { bindReporter } from './lib/bindReporter.js';\nimport { getActivationStart } from './lib/getActivationStart.js';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst reportedMetricIDs = {};\n\n/**\n * Calculates the [LCP](https://web.dev/lcp/) value for the current page and\n * calls the `callback` function once the value is ready (along with the\n * relevant `largest-contentful-paint` performance entry used to determine the\n * value). The reported value is a `DOMHighResTimeStamp`.\n *\n * If the `reportAllChanges` configuration option is set to `true`, the\n * `callback` function will be called any time a new `largest-contentful-paint`\n * performance entry is dispatched, or once the final value of the metric has\n * been determined.\n */\nconst onLCP = (onReport, opts = {}) => {\n  const visibilityWatcher = getVisibilityWatcher();\n  const metric = initMetric('LCP');\n  let report;\n\n  const handleEntries = (entries) => {\n    const lastEntry = entries[entries.length - 1] ;\n    if (lastEntry) {\n      // The startTime attribute returns the value of the renderTime if it is\n      // not 0, and the value of the loadTime otherwise. The activationStart\n      // reference is used because LCP should be relative to page activation\n      // rather than navigation start if the page was prerendered.\n      const value = Math.max(lastEntry.startTime - getActivationStart(), 0);\n\n      // Only report if the page wasn't hidden prior to LCP.\n      if (value < visibilityWatcher.firstHiddenTime) {\n        metric.value = value;\n        metric.entries = [lastEntry];\n        report();\n      }\n    }\n  };\n\n  const po = observe('largest-contentful-paint', handleEntries);\n\n  if (po) {\n    report = bindReporter(onReport, metric, opts.reportAllChanges);\n\n    const stopListening = () => {\n      if (!reportedMetricIDs[metric.id]) {\n        handleEntries(po.takeRecords() );\n        po.disconnect();\n        reportedMetricIDs[metric.id] = true;\n        report(true);\n      }\n    };\n\n    // Stop listening after input. Note: while scrolling is an input that\n    // stop LCP observation, it's unreliable since it can be programmatically\n    // generated. See: https://github.com/GoogleChrome/web-vitals/issues/75\n    ['keydown', 'click'].forEach(type => {\n      addEventListener(type, stopListening, { once: true, capture: true });\n    });\n\n    onHidden(stopListening, true);\n  }\n};\n\nexport { onLCP };\n//# sourceMappingURL=getLCP.js.map\n","/**\n * Checks if a given value is a valid measurement value.\n */\nfunction isMeasurementValue(value) {\n  return typeof value === 'number' && isFinite(value);\n}\n\n/**\n * Helper function to start child on transactions. This function will make sure that the transaction will\n * use the start timestamp of the created child span if it is earlier than the transactions actual\n * start timestamp.\n */\nfunction _startChild(transaction, { startTimestamp, ...ctx }) {\n  if (startTimestamp && transaction.startTimestamp > startTimestamp) {\n    transaction.startTimestamp = startTimestamp;\n  }\n\n  return transaction.startChild({\n    startTimestamp,\n    ...ctx,\n  });\n}\n\nexport { _startChild, isMeasurementValue };\n//# sourceMappingURL=utils.js.map\n","import { _nullishCoalesce } from '@sentry/utils/esm/buildPolyfills';\nimport { browserPerformanceTimeOrigin, logger, htmlTreeAsString } from '@sentry/utils';\nimport { getActiveTransaction, msToSec } from '../../utils.js';\nimport { WINDOW } from '../types.js';\nimport { onCLS } from '../web-vitals/getCLS.js';\nimport { onFID } from '../web-vitals/getFID.js';\nimport { onLCP } from '../web-vitals/getLCP.js';\nimport { getVisibilityWatcher } from '../web-vitals/lib/getVisibilityWatcher.js';\nimport { observe } from '../web-vitals/lib/observe.js';\nimport { _startChild, isMeasurementValue } from './utils.js';\n\nfunction getBrowserPerformanceAPI() {\n  return WINDOW && WINDOW.addEventListener && WINDOW.performance;\n}\n\nlet _performanceCursor = 0;\n\nlet _measurements = {};\nlet _lcpEntry;\nlet _clsEntry;\n\n/**\n * Start tracking web vitals\n */\nfunction startTrackingWebVitals(reportAllChanges = false) {\n  const performance = getBrowserPerformanceAPI();\n  if (performance && browserPerformanceTimeOrigin) {\n    if (performance.mark) {\n      WINDOW.performance.mark('sentry-tracing-init');\n    }\n    _trackCLS();\n    _trackLCP(reportAllChanges);\n    _trackFID();\n  }\n}\n\n/**\n * Start tracking long tasks.\n */\nfunction startTrackingLongTasks() {\n  const entryHandler = (entries) => {\n    for (const entry of entries) {\n      const transaction = getActiveTransaction() ;\n      if (!transaction) {\n        return;\n      }\n      const startTime = msToSec((browserPerformanceTimeOrigin ) + entry.startTime);\n      const duration = msToSec(entry.duration);\n\n      transaction.startChild({\n        description: 'Main UI thread blocked',\n        op: 'ui.long-task',\n        startTimestamp: startTime,\n        endTimestamp: startTime + duration,\n      });\n    }\n  };\n\n  observe('longtask', entryHandler);\n}\n\n/** Starts tracking the Cumulative Layout Shift on the current page. */\nfunction _trackCLS() {\n  // See:\n  // https://web.dev/evolving-cls/\n  // https://web.dev/cls-web-tooling/\n  onCLS(metric => {\n    const entry = metric.entries.pop();\n    if (!entry) {\n      return;\n    }\n\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding CLS');\n    _measurements['cls'] = { value: metric.value, unit: '' };\n    _clsEntry = entry ;\n  });\n}\n\n/** Starts tracking the Largest Contentful Paint on the current page. */\nfunction _trackLCP(reportAllChanges) {\n  onLCP(\n    metric => {\n      const entry = metric.entries.pop();\n      if (!entry) {\n        return;\n      }\n\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding LCP');\n      _measurements['lcp'] = { value: metric.value, unit: 'millisecond' };\n      _lcpEntry = entry ;\n    },\n    { reportAllChanges },\n  );\n}\n\n/** Starts tracking the First Input Delay on the current page. */\nfunction _trackFID() {\n  onFID(metric => {\n    const entry = metric.entries.pop();\n    if (!entry) {\n      return;\n    }\n\n    const timeOrigin = msToSec(browserPerformanceTimeOrigin );\n    const startTime = msToSec(entry.startTime);\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding FID');\n    _measurements['fid'] = { value: metric.value, unit: 'millisecond' };\n    _measurements['mark.fid'] = { value: timeOrigin + startTime, unit: 'second' };\n  });\n}\n\n/** Add performance related spans to a transaction */\nfunction addPerformanceEntries(transaction) {\n  const performance = getBrowserPerformanceAPI();\n  if (!performance || !WINDOW.performance.getEntries || !browserPerformanceTimeOrigin) {\n    // Gatekeeper if performance API not available\n    return;\n  }\n\n  (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] Adding & adjusting spans using Performance API');\n  const timeOrigin = msToSec(browserPerformanceTimeOrigin);\n\n  const performanceEntries = performance.getEntries();\n\n  let responseStartTimestamp;\n  let requestStartTimestamp;\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  performanceEntries.slice(_performanceCursor).forEach((entry) => {\n    const startTime = msToSec(entry.startTime);\n    const duration = msToSec(entry.duration);\n\n    if (transaction.op === 'navigation' && timeOrigin + startTime < transaction.startTimestamp) {\n      return;\n    }\n\n    switch (entry.entryType) {\n      case 'navigation': {\n        _addNavigationSpans(transaction, entry, timeOrigin);\n        responseStartTimestamp = timeOrigin + msToSec(entry.responseStart);\n        requestStartTimestamp = timeOrigin + msToSec(entry.requestStart);\n        break;\n      }\n      case 'mark':\n      case 'paint':\n      case 'measure': {\n        _addMeasureSpans(transaction, entry, startTime, duration, timeOrigin);\n\n        // capture web vitals\n        const firstHidden = getVisibilityWatcher();\n        // Only report if the page wasn't hidden prior to the web vital.\n        const shouldRecord = entry.startTime < firstHidden.firstHiddenTime;\n\n        if (entry.name === 'first-paint' && shouldRecord) {\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding FP');\n          _measurements['fp'] = { value: entry.startTime, unit: 'millisecond' };\n        }\n        if (entry.name === 'first-contentful-paint' && shouldRecord) {\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding FCP');\n          _measurements['fcp'] = { value: entry.startTime, unit: 'millisecond' };\n        }\n        break;\n      }\n      case 'resource': {\n        const resourceName = (entry.name ).replace(WINDOW.location.origin, '');\n        _addResourceSpans(transaction, entry, resourceName, startTime, duration, timeOrigin);\n        break;\n      }\n      default:\n      // Ignore other entry types.\n    }\n  });\n\n  _performanceCursor = Math.max(performanceEntries.length - 1, 0);\n\n  _trackNavigator(transaction);\n\n  // Measurements are only available for pageload transactions\n  if (transaction.op === 'pageload') {\n    // Generate TTFB (Time to First Byte), which measured as the time between the beginning of the transaction and the\n    // start of the response in milliseconds\n    if (typeof responseStartTimestamp === 'number') {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding TTFB');\n      _measurements['ttfb'] = {\n        value: (responseStartTimestamp - transaction.startTimestamp) * 1000,\n        unit: 'millisecond',\n      };\n\n      if (typeof requestStartTimestamp === 'number' && requestStartTimestamp <= responseStartTimestamp) {\n        // Capture the time spent making the request and receiving the first byte of the response.\n        // This is the time between the start of the request and the start of the response in milliseconds.\n        _measurements['ttfb.requestTime'] = {\n          value: (responseStartTimestamp - requestStartTimestamp) * 1000,\n          unit: 'millisecond',\n        };\n      }\n    }\n\n    ['fcp', 'fp', 'lcp'].forEach(name => {\n      if (!_measurements[name] || timeOrigin >= transaction.startTimestamp) {\n        return;\n      }\n      // The web vitals, fcp, fp, lcp, and ttfb, all measure relative to timeOrigin.\n      // Unfortunately, timeOrigin is not captured within the transaction span data, so these web vitals will need\n      // to be adjusted to be relative to transaction.startTimestamp.\n      const oldValue = _measurements[name].value;\n      const measurementTimestamp = timeOrigin + msToSec(oldValue);\n\n      // normalizedValue should be in milliseconds\n      const normalizedValue = Math.abs((measurementTimestamp - transaction.startTimestamp) * 1000);\n      const delta = normalizedValue - oldValue;\n\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.log(`[Measurements] Normalized ${name} from ${oldValue} to ${normalizedValue} (${delta})`);\n      _measurements[name].value = normalizedValue;\n    });\n\n    const fidMark = _measurements['mark.fid'];\n    if (fidMark && _measurements['fid']) {\n      // create span for FID\n      _startChild(transaction, {\n        description: 'first input delay',\n        endTimestamp: fidMark.value + msToSec(_measurements['fid'].value),\n        op: 'ui.action',\n        startTimestamp: fidMark.value,\n      });\n\n      // Delete mark.fid as we don't want it to be part of final payload\n      delete _measurements['mark.fid'];\n    }\n\n    // If FCP is not recorded we should not record the cls value\n    // according to the new definition of CLS.\n    if (!('fcp' in _measurements)) {\n      delete _measurements.cls;\n    }\n\n    Object.keys(_measurements).forEach(measurementName => {\n      transaction.setMeasurement(\n        measurementName,\n        _measurements[measurementName].value,\n        _measurements[measurementName].unit,\n      );\n    });\n\n    _tagMetricInfo(transaction);\n  }\n\n  _lcpEntry = undefined;\n  _clsEntry = undefined;\n  _measurements = {};\n}\n\n/** Create measure related spans */\nfunction _addMeasureSpans(\n  transaction,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  entry,\n  startTime,\n  duration,\n  timeOrigin,\n) {\n  const measureStartTimestamp = timeOrigin + startTime;\n  const measureEndTimestamp = measureStartTimestamp + duration;\n\n  _startChild(transaction, {\n    description: entry.name ,\n    endTimestamp: measureEndTimestamp,\n    op: entry.entryType ,\n    startTimestamp: measureStartTimestamp,\n  });\n\n  return measureStartTimestamp;\n}\n\n/** Instrument navigation entries */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _addNavigationSpans(transaction, entry, timeOrigin) {\n  ['unloadEvent', 'redirect', 'domContentLoadedEvent', 'loadEvent', 'connect'].forEach(event => {\n    _addPerformanceNavigationTiming(transaction, entry, event, timeOrigin);\n  });\n  _addPerformanceNavigationTiming(transaction, entry, 'secureConnection', timeOrigin, 'TLS/SSL', 'connectEnd');\n  _addPerformanceNavigationTiming(transaction, entry, 'fetch', timeOrigin, 'cache', 'domainLookupStart');\n  _addPerformanceNavigationTiming(transaction, entry, 'domainLookup', timeOrigin, 'DNS');\n  _addRequest(transaction, entry, timeOrigin);\n}\n\n/** Create performance navigation related spans */\nfunction _addPerformanceNavigationTiming(\n  transaction,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  entry,\n  event,\n  timeOrigin,\n  description,\n  eventEnd,\n) {\n  const end = eventEnd ? (entry[eventEnd] ) : (entry[`${event}End`] );\n  const start = entry[`${event}Start`] ;\n  if (!start || !end) {\n    return;\n  }\n  _startChild(transaction, {\n    op: 'browser',\n    description: _nullishCoalesce(description, () => ( event)),\n    startTimestamp: timeOrigin + msToSec(start),\n    endTimestamp: timeOrigin + msToSec(end),\n  });\n}\n\n/** Create request and response related spans */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _addRequest(transaction, entry, timeOrigin) {\n  _startChild(transaction, {\n    op: 'browser',\n    description: 'request',\n    startTimestamp: timeOrigin + msToSec(entry.requestStart ),\n    endTimestamp: timeOrigin + msToSec(entry.responseEnd ),\n  });\n\n  _startChild(transaction, {\n    op: 'browser',\n    description: 'response',\n    startTimestamp: timeOrigin + msToSec(entry.responseStart ),\n    endTimestamp: timeOrigin + msToSec(entry.responseEnd ),\n  });\n}\n\n/** Create resource-related spans */\nfunction _addResourceSpans(\n  transaction,\n  entry,\n  resourceName,\n  startTime,\n  duration,\n  timeOrigin,\n) {\n  // we already instrument based on fetch and xhr, so we don't need to\n  // duplicate spans here.\n  if (entry.initiatorType === 'xmlhttprequest' || entry.initiatorType === 'fetch') {\n    return;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const data = {};\n  if ('transferSize' in entry) {\n    data['Transfer Size'] = entry.transferSize;\n  }\n  if ('encodedBodySize' in entry) {\n    data['Encoded Body Size'] = entry.encodedBodySize;\n  }\n  if ('decodedBodySize' in entry) {\n    data['Decoded Body Size'] = entry.decodedBodySize;\n  }\n\n  const startTimestamp = timeOrigin + startTime;\n  const endTimestamp = startTimestamp + duration;\n\n  _startChild(transaction, {\n    description: resourceName,\n    endTimestamp,\n    op: entry.initiatorType ? `resource.${entry.initiatorType}` : 'resource.other',\n    startTimestamp,\n    data,\n  });\n}\n\n/**\n * Capture the information of the user agent.\n */\nfunction _trackNavigator(transaction) {\n  const navigator = WINDOW.navigator ;\n  if (!navigator) {\n    return;\n  }\n\n  // track network connectivity\n  const connection = navigator.connection;\n  if (connection) {\n    if (connection.effectiveType) {\n      transaction.setTag('effectiveConnectionType', connection.effectiveType);\n    }\n\n    if (connection.type) {\n      transaction.setTag('connectionType', connection.type);\n    }\n\n    if (isMeasurementValue(connection.rtt)) {\n      _measurements['connection.rtt'] = { value: connection.rtt, unit: 'millisecond' };\n    }\n  }\n\n  if (isMeasurementValue(navigator.deviceMemory)) {\n    transaction.setTag('deviceMemory', `${navigator.deviceMemory} GB`);\n  }\n\n  if (isMeasurementValue(navigator.hardwareConcurrency)) {\n    transaction.setTag('hardwareConcurrency', String(navigator.hardwareConcurrency));\n  }\n}\n\n/** Add LCP / CLS data to transaction to allow debugging */\nfunction _tagMetricInfo(transaction) {\n  if (_lcpEntry) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding LCP Data');\n\n    // Capture Properties of the LCP element that contributes to the LCP.\n\n    if (_lcpEntry.element) {\n      transaction.setTag('lcp.element', htmlTreeAsString(_lcpEntry.element));\n    }\n\n    if (_lcpEntry.id) {\n      transaction.setTag('lcp.id', _lcpEntry.id);\n    }\n\n    if (_lcpEntry.url) {\n      // Trim URL to the first 200 characters.\n      transaction.setTag('lcp.url', _lcpEntry.url.trim().slice(0, 200));\n    }\n\n    transaction.setTag('lcp.size', _lcpEntry.size);\n  }\n\n  // See: https://developer.mozilla.org/en-US/docs/Web/API/LayoutShift\n  if (_clsEntry && _clsEntry.sources) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Measurements] Adding CLS Data');\n    _clsEntry.sources.forEach((source, index) =>\n      transaction.setTag(`cls.source.${index + 1}`, htmlTreeAsString(source.node)),\n    );\n  }\n}\n\nexport { _addMeasureSpans, _addResourceSpans, addPerformanceEntries, startTrackingLongTasks, startTrackingWebVitals };\n//# sourceMappingURL=index.js.map\n","import { bindReporter } from './lib/bindReporter.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Calculates the [CLS](https://web.dev/cls/) value for the current page and\n * calls the `callback` function once the value is ready to be reported, along\n * with all `layout-shift` performance entries that were used in the metric\n * value calculation. The reported value is a `double` (corresponding to a\n * [layout shift score](https://web.dev/cls/#layout-shift-score)).\n *\n * If the `reportAllChanges` configuration option is set to `true`, the\n * `callback` function will be called as soon as the value is initially\n * determined as well as any time the value changes throughout the page\n * lifespan.\n *\n * _**Important:** CLS should be continually monitored for changes throughout\n * the entire lifespan of a page—including if the user returns to the page after\n * it's been hidden/backgrounded. However, since browsers often [will not fire\n * additional callbacks once the user has backgrounded a\n * page](https://developer.chrome.com/blog/page-lifecycle-api/#advice-hidden),\n * `callback` is always called when the page's visibility state changes to\n * hidden. As a result, the `callback` function might be called multiple times\n * during the same page load._\n */\nconst onCLS = (onReport, opts = {}) => {\n  const metric = initMetric('CLS', 0);\n  let report;\n\n  let sessionValue = 0;\n  let sessionEntries = [];\n\n  // const handleEntries = (entries: Metric['entries']) => {\n  const handleEntries = (entries) => {\n    entries.forEach(entry => {\n      // Only count layout shifts without recent user input.\n      if (!entry.hadRecentInput) {\n        const firstSessionEntry = sessionEntries[0];\n        const lastSessionEntry = sessionEntries[sessionEntries.length - 1];\n\n        // If the entry occurred less than 1 second after the previous entry and\n        // less than 5 seconds after the first entry in the session, include the\n        // entry in the current session. Otherwise, start a new session.\n        if (\n          sessionValue &&\n          sessionEntries.length !== 0 &&\n          entry.startTime - lastSessionEntry.startTime < 1000 &&\n          entry.startTime - firstSessionEntry.startTime < 5000\n        ) {\n          sessionValue += entry.value;\n          sessionEntries.push(entry);\n        } else {\n          sessionValue = entry.value;\n          sessionEntries = [entry];\n        }\n\n        // If the current session value is larger than the current CLS value,\n        // update CLS and the entries contributing to it.\n        if (sessionValue > metric.value) {\n          metric.value = sessionValue;\n          metric.entries = sessionEntries;\n          if (report) {\n            report();\n          }\n        }\n      }\n    });\n  };\n\n  const po = observe('layout-shift', handleEntries);\n  if (po) {\n    report = bindReporter(onReport, metric, opts.reportAllChanges);\n\n    onHidden(() => {\n      handleEntries(po.takeRecords() );\n      report(true);\n    });\n  }\n};\n\nexport { onCLS };\n//# sourceMappingURL=getCLS.js.map\n","import { bindReporter } from './lib/bindReporter.js';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Calculates the [FID](https://web.dev/fid/) value for the current page and\n * calls the `callback` function once the value is ready, along with the\n * relevant `first-input` performance entry used to determine the value. The\n * reported value is a `DOMHighResTimeStamp`.\n *\n * _**Important:** since FID is only reported after the user interacts with the\n * page, it's possible that it will not be reported for some page loads._\n */\nconst onFID = (onReport, opts = {}) => {\n  const visibilityWatcher = getVisibilityWatcher();\n  const metric = initMetric('FID');\n  // eslint-disable-next-line prefer-const\n  let report;\n\n  const handleEntry = (entry) => {\n    // Only report if the page wasn't hidden prior to the first input.\n    if (entry.startTime < visibilityWatcher.firstHiddenTime) {\n      metric.value = entry.processingStart - entry.startTime;\n      metric.entries.push(entry);\n      report(true);\n    }\n  };\n\n  const handleEntries = (entries) => {\n    (entries ).forEach(handleEntry);\n  };\n\n  const po = observe('first-input', handleEntries);\n  report = bindReporter(onReport, metric, opts.reportAllChanges);\n\n  if (po) {\n    onHidden(() => {\n      handleEntries(po.takeRecords() );\n      po.disconnect();\n    }, true);\n  }\n};\n\nexport { onFID };\n//# sourceMappingURL=getFID.js.map\n","import { isMatchingPattern, addInstrumentationHandler, dynamicSamplingContextToSentryBaggageHeader, isInstanceOf, BAGGAGE_HEADER_NAME } from '@sentry/utils';\nimport { hasTracingEnabled, getActiveTransaction } from '../utils.js';\n\nconst DEFAULT_TRACING_ORIGINS = ['localhost', /^\\//];\n\n/** Options for Request Instrumentation */\n\nconst defaultRequestInstrumentationOptions = {\n  traceFetch: true,\n  traceXHR: true,\n  tracingOrigins: DEFAULT_TRACING_ORIGINS,\n};\n\n/** Registers span creators for xhr and fetch requests  */\nfunction instrumentOutgoingRequests(_options) {\n  const { traceFetch, traceXHR, tracingOrigins, shouldCreateSpanForRequest } = {\n    ...defaultRequestInstrumentationOptions,\n    ..._options,\n  };\n\n  const shouldCreateSpan =\n    typeof shouldCreateSpanForRequest === 'function' ? shouldCreateSpanForRequest : (_) => true;\n\n  const shouldAttachHeaders = (url) => tracingOrigins.some(origin => isMatchingPattern(url, origin));\n\n  const spans = {};\n\n  if (traceFetch) {\n    addInstrumentationHandler('fetch', (handlerData) => {\n      fetchCallback(handlerData, shouldCreateSpan, shouldAttachHeaders, spans);\n    });\n  }\n\n  if (traceXHR) {\n    addInstrumentationHandler('xhr', (handlerData) => {\n      xhrCallback(handlerData, shouldCreateSpan, shouldAttachHeaders, spans);\n    });\n  }\n}\n\n/**\n * Create and track fetch request spans\n */\nfunction fetchCallback(\n  handlerData,\n  shouldCreateSpan,\n  shouldAttachHeaders,\n  spans,\n) {\n  if (!hasTracingEnabled() || !(handlerData.fetchData && shouldCreateSpan(handlerData.fetchData.url))) {\n    return;\n  }\n\n  if (handlerData.endTimestamp) {\n    const spanId = handlerData.fetchData.__span;\n    if (!spanId) return;\n\n    const span = spans[spanId];\n    if (span) {\n      if (handlerData.response) {\n        // TODO (kmclb) remove this once types PR goes through\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        span.setHttpStatus(handlerData.response.status);\n      } else if (handlerData.error) {\n        span.setStatus('internal_error');\n      }\n      span.finish();\n\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete spans[spanId];\n    }\n    return;\n  }\n\n  const activeTransaction = getActiveTransaction();\n  if (activeTransaction) {\n    const span = activeTransaction.startChild({\n      data: {\n        ...handlerData.fetchData,\n        type: 'fetch',\n      },\n      description: `${handlerData.fetchData.method} ${handlerData.fetchData.url}`,\n      op: 'http.client',\n    });\n\n    handlerData.fetchData.__span = span.spanId;\n    spans[span.spanId] = span;\n\n    const request = handlerData.args[0];\n\n    // In case the user hasn't set the second argument of a fetch call we default it to `{}`.\n    handlerData.args[1] = handlerData.args[1] || {};\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const options = handlerData.args[1];\n\n    if (shouldAttachHeaders(handlerData.fetchData.url)) {\n      options.headers = addTracingHeadersToFetchRequest(\n        request,\n        activeTransaction.getDynamicSamplingContext(),\n        span,\n        options,\n      );\n\n      activeTransaction.metadata.propagations += 1;\n    }\n  }\n}\n\nfunction addTracingHeadersToFetchRequest(\n  request,\n  dynamicSamplingContext,\n  span,\n  options\n\n,\n) {\n  const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);\n  const sentryTraceHeader = span.toTraceparent();\n\n  const headers =\n    typeof Request !== 'undefined' && isInstanceOf(request, Request) ? (request ).headers : options.headers;\n\n  if (!headers) {\n    return { 'sentry-trace': sentryTraceHeader, baggage: sentryBaggageHeader };\n  } else if (typeof Headers !== 'undefined' && isInstanceOf(headers, Headers)) {\n    const newHeaders = new Headers(headers );\n\n    newHeaders.append('sentry-trace', sentryTraceHeader);\n\n    if (sentryBaggageHeader) {\n      // If the same header is appended miultiple times the browser will merge the values into a single request header.\n      // Its therefore safe to simply push a \"baggage\" entry, even though there might already be another baggage header.\n      newHeaders.append(BAGGAGE_HEADER_NAME, sentryBaggageHeader);\n    }\n\n    return newHeaders ;\n  } else if (Array.isArray(headers)) {\n    const newHeaders = [...headers, ['sentry-trace', sentryTraceHeader]];\n\n    if (sentryBaggageHeader) {\n      // If there are multiple entries with the same key, the browser will merge the values into a single request header.\n      // Its therefore safe to simply push a \"baggage\" entry, even though there might already be another baggage header.\n      newHeaders.push([BAGGAGE_HEADER_NAME, sentryBaggageHeader]);\n    }\n\n    return newHeaders;\n  } else {\n    const existingBaggageHeader = 'baggage' in headers ? headers.baggage : undefined;\n    const newBaggageHeaders = [];\n\n    if (Array.isArray(existingBaggageHeader)) {\n      newBaggageHeaders.push(...existingBaggageHeader);\n    } else if (existingBaggageHeader) {\n      newBaggageHeaders.push(existingBaggageHeader);\n    }\n\n    if (sentryBaggageHeader) {\n      newBaggageHeaders.push(sentryBaggageHeader);\n    }\n\n    return {\n      ...(headers ),\n      'sentry-trace': sentryTraceHeader,\n      baggage: newBaggageHeaders.length > 0 ? newBaggageHeaders.join(',') : undefined,\n    };\n  }\n}\n\n/**\n * Create and track xhr request spans\n */\nfunction xhrCallback(\n  handlerData,\n  shouldCreateSpan,\n  shouldAttachHeaders,\n  spans,\n) {\n  if (\n    !hasTracingEnabled() ||\n    (handlerData.xhr && handlerData.xhr.__sentry_own_request__) ||\n    !(handlerData.xhr && handlerData.xhr.__sentry_xhr__ && shouldCreateSpan(handlerData.xhr.__sentry_xhr__.url))\n  ) {\n    return;\n  }\n\n  const xhr = handlerData.xhr.__sentry_xhr__;\n\n  // check first if the request has finished and is tracked by an existing span which should now end\n  if (handlerData.endTimestamp) {\n    const spanId = handlerData.xhr.__sentry_xhr_span_id__;\n    if (!spanId) return;\n\n    const span = spans[spanId];\n    if (span) {\n      span.setHttpStatus(xhr.status_code);\n      span.finish();\n\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete spans[spanId];\n    }\n    return;\n  }\n\n  // if not, create a new span to track it\n  const activeTransaction = getActiveTransaction();\n  if (activeTransaction) {\n    const span = activeTransaction.startChild({\n      data: {\n        ...xhr.data,\n        type: 'xhr',\n        method: xhr.method,\n        url: xhr.url,\n      },\n      description: `${xhr.method} ${xhr.url}`,\n      op: 'http.client',\n    });\n\n    handlerData.xhr.__sentry_xhr_span_id__ = span.spanId;\n    spans[handlerData.xhr.__sentry_xhr_span_id__] = span;\n\n    if (handlerData.xhr.setRequestHeader && shouldAttachHeaders(handlerData.xhr.__sentry_xhr__.url)) {\n      try {\n        handlerData.xhr.setRequestHeader('sentry-trace', span.toTraceparent());\n\n        const dynamicSamplingContext = activeTransaction.getDynamicSamplingContext();\n        const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(dynamicSamplingContext);\n\n        if (sentryBaggageHeader) {\n          // From MDN: \"If this method is called several times with the same header, the values are merged into one single request header.\"\n          // We can therefore simply set a baggage header without checking what was there before\n          // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/setRequestHeader\n          handlerData.xhr.setRequestHeader(BAGGAGE_HEADER_NAME, sentryBaggageHeader);\n        }\n\n        activeTransaction.metadata.propagations += 1;\n      } catch (_) {\n        // Error: InvalidStateError: Failed to execute 'setRequestHeader' on 'XMLHttpRequest': The object's state must be OPENED.\n      }\n    }\n  }\n}\n\nexport { DEFAULT_TRACING_ORIGINS, defaultRequestInstrumentationOptions, fetchCallback, instrumentOutgoingRequests, xhrCallback };\n//# sourceMappingURL=request.js.map\n","import { _optionalChain } from '@sentry/utils/esm/buildPolyfills';\nimport { logger, extractTraceparentData, baggageHeaderToDynamicSamplingContext, getDomElement } from '@sentry/utils';\nimport { startIdleTransaction } from '../hubextensions.js';\nimport { DEFAULT_IDLE_TIMEOUT, DEFAULT_FINAL_TIMEOUT, DEFAULT_HEARTBEAT_INTERVAL } from '../idletransaction.js';\nimport '../utils.js';\nimport { registerBackgroundTabDetection } from './backgroundtab.js';\nimport { startTrackingWebVitals, startTrackingLongTasks, addPerformanceEntries } from './metrics/index.js';\nimport { defaultRequestInstrumentationOptions, instrumentOutgoingRequests } from './request.js';\nimport { instrumentRoutingWithDefaults } from './router.js';\nimport { WINDOW } from './types.js';\n\nconst BROWSER_TRACING_INTEGRATION_ID = 'BrowserTracing';\n\n/** Options for Browser Tracing integration */\n\nconst DEFAULT_BROWSER_TRACING_OPTIONS = {\n  idleTimeout: DEFAULT_IDLE_TIMEOUT,\n  finalTimeout: DEFAULT_FINAL_TIMEOUT,\n  heartbeatInterval: DEFAULT_HEARTBEAT_INTERVAL,\n  markBackgroundTransactions: true,\n  routingInstrumentation: instrumentRoutingWithDefaults,\n  startTransactionOnLocationChange: true,\n  startTransactionOnPageLoad: true,\n  _experiments: { enableLongTask: true },\n  ...defaultRequestInstrumentationOptions,\n};\n\n/**\n * The Browser Tracing integration automatically instruments browser pageload/navigation\n * actions as transactions, and captures requests, metrics and errors as spans.\n *\n * The integration can be configured with a variety of options, and can be extended to use\n * any routing library. This integration uses {@see IdleTransaction} to create transactions.\n */\nclass BrowserTracing  {\n  // This class currently doesn't have a static `id` field like the other integration classes, because it prevented\n  // @sentry/tracing from being treeshaken. Tree shakers do not like static fields, because they behave like side effects.\n  // TODO: Come up with a better plan, than using static fields on integration classes, and use that plan on all\n  // integrations.\n\n  /** Browser Tracing integration options */\n\n  /**\n   * @inheritDoc\n   */\n   __init() {this.name = BROWSER_TRACING_INTEGRATION_ID;}\n\n   constructor(_options) {;BrowserTracing.prototype.__init.call(this);\n    let tracingOrigins = defaultRequestInstrumentationOptions.tracingOrigins;\n    // NOTE: Logger doesn't work in constructors, as it's initialized after integrations instances\n    if (_options) {\n      if (_options.tracingOrigins && Array.isArray(_options.tracingOrigins)) {\n        tracingOrigins = _options.tracingOrigins;\n      } else {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && (this._emitOptionsWarning = true);\n      }\n    }\n\n    this.options = {\n      ...DEFAULT_BROWSER_TRACING_OPTIONS,\n      ..._options,\n      tracingOrigins,\n    };\n\n    const { _metricOptions } = this.options;\n    startTrackingWebVitals(_metricOptions && _metricOptions._reportAllChanges);\n    if (_optionalChain([this, 'access', _2 => _2.options, 'access', _3 => _3._experiments, 'optionalAccess', _4 => _4.enableLongTask])) {\n      startTrackingLongTasks();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setupOnce(_, getCurrentHub) {\n    this._getCurrentHub = getCurrentHub;\n\n    if (this._emitOptionsWarning) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn(\n          '[Tracing] You need to define `tracingOrigins` in the options. Set an array of urls or patterns to trace.',\n        );\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn(\n          `[Tracing] We added a reasonable default for you: ${defaultRequestInstrumentationOptions.tracingOrigins}`,\n        );\n    }\n\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    const {\n      routingInstrumentation: instrumentRouting,\n      startTransactionOnLocationChange,\n      startTransactionOnPageLoad,\n      markBackgroundTransactions,\n      traceFetch,\n      traceXHR,\n      tracingOrigins,\n      shouldCreateSpanForRequest,\n    } = this.options;\n\n    instrumentRouting(\n      (context) => this._createRouteTransaction(context),\n      startTransactionOnPageLoad,\n      startTransactionOnLocationChange,\n    );\n\n    if (markBackgroundTransactions) {\n      registerBackgroundTabDetection();\n    }\n\n    instrumentOutgoingRequests({ traceFetch, traceXHR, tracingOrigins, shouldCreateSpanForRequest });\n  }\n\n  /** Create routing idle transaction. */\n   _createRouteTransaction(context) {\n    if (!this._getCurrentHub) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn(`[Tracing] Did not create ${context.op} transaction because _getCurrentHub is invalid.`);\n      return undefined;\n    }\n\n    // eslint-disable-next-line @typescript-eslint/unbound-method\n    const { beforeNavigate, idleTimeout, finalTimeout, heartbeatInterval } = this.options;\n\n    const isPageloadTransaction = context.op === 'pageload';\n\n    const sentryTraceMetaTagValue = isPageloadTransaction ? getMetaContent('sentry-trace') : null;\n    const baggageMetaTagValue = isPageloadTransaction ? getMetaContent('baggage') : null;\n\n    const traceParentData = sentryTraceMetaTagValue ? extractTraceparentData(sentryTraceMetaTagValue) : undefined;\n    const dynamicSamplingContext = baggageMetaTagValue\n      ? baggageHeaderToDynamicSamplingContext(baggageMetaTagValue)\n      : undefined;\n\n    const expandedContext = {\n      ...context,\n      ...traceParentData,\n      metadata: {\n        ...context.metadata,\n        dynamicSamplingContext: traceParentData && !dynamicSamplingContext ? {} : dynamicSamplingContext,\n      },\n      trimEnd: true,\n    };\n\n    const modifiedContext = typeof beforeNavigate === 'function' ? beforeNavigate(expandedContext) : expandedContext;\n\n    // For backwards compatibility reasons, beforeNavigate can return undefined to \"drop\" the transaction (prevent it\n    // from being sent to Sentry).\n    const finalContext = modifiedContext === undefined ? { ...expandedContext, sampled: false } : modifiedContext;\n\n    // If `beforeNavigate` set a custom name, record that fact\n    finalContext.metadata =\n      finalContext.name !== expandedContext.name\n        ? { ...finalContext.metadata, source: 'custom' }\n        : finalContext.metadata;\n\n    if (finalContext.sampled === false) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.log(`[Tracing] Will not send ${finalContext.op} transaction because of beforeNavigate.`);\n    }\n\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] Starting ${finalContext.op} transaction on scope`);\n\n    const hub = this._getCurrentHub();\n    const { location } = WINDOW;\n\n    const idleTransaction = startIdleTransaction(\n      hub,\n      finalContext,\n      idleTimeout,\n      finalTimeout,\n      true,\n      { location }, // for use in the tracesSampler\n      heartbeatInterval,\n    );\n    idleTransaction.registerBeforeFinishCallback(transaction => {\n      addPerformanceEntries(transaction);\n      transaction.setTag(\n        'sentry_reportAllChanges',\n        Boolean(this.options._metricOptions && this.options._metricOptions._reportAllChanges),\n      );\n    });\n\n    return idleTransaction ;\n  }\n}\n\n/** Returns the value of a meta tag */\nfunction getMetaContent(metaName) {\n  // Can't specify generic to `getDomElement` because tracing can be used\n  // in a variety of environments, have to disable `no-unsafe-member-access`\n  // as a result.\n  const metaTag = getDomElement(`meta[name=${metaName}]`);\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return metaTag ? metaTag.getAttribute('content') : null;\n}\n\nexport { BROWSER_TRACING_INTEGRATION_ID, BrowserTracing, getMetaContent };\n//# sourceMappingURL=browsertracing.js.map\n","import { logger, addInstrumentationHandler } from '@sentry/utils';\nimport { WINDOW } from './types.js';\n\n/**\n * Default function implementing pageload and navigation transactions\n */\nfunction instrumentRoutingWithDefaults(\n  customStartTransaction,\n  startTransactionOnPageLoad = true,\n  startTransactionOnLocationChange = true,\n) {\n  if (!WINDOW || !WINDOW.location) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Could not initialize routing instrumentation due to invalid location');\n    return;\n  }\n\n  let startingUrl = WINDOW.location.href;\n\n  let activeTransaction;\n  if (startTransactionOnPageLoad) {\n    activeTransaction = customStartTransaction({\n      name: WINDOW.location.pathname,\n      op: 'pageload',\n      metadata: { source: 'url' },\n    });\n  }\n\n  if (startTransactionOnLocationChange) {\n    addInstrumentationHandler('history', ({ to, from }) => {\n      /**\n       * This early return is there to account for some cases where a navigation transaction starts right after\n       * long-running pageload. We make sure that if `from` is undefined and a valid `startingURL` exists, we don't\n       * create an uneccessary navigation transaction.\n       *\n       * This was hard to duplicate, but this behavior stopped as soon as this fix was applied. This issue might also\n       * only be caused in certain development environments where the usage of a hot module reloader is causing\n       * errors.\n       */\n      if (from === undefined && startingUrl && startingUrl.indexOf(to) !== -1) {\n        startingUrl = undefined;\n        return;\n      }\n\n      if (from !== to) {\n        startingUrl = undefined;\n        if (activeTransaction) {\n          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] Finishing current transaction with op: ${activeTransaction.op}`);\n          // If there's an open transaction on the scope, we need to finish it before creating an new one.\n          activeTransaction.finish();\n        }\n        activeTransaction = customStartTransaction({\n          name: WINDOW.location.pathname,\n          op: 'navigation',\n          metadata: { source: 'url' },\n        });\n      }\n    });\n  }\n}\n\nexport { instrumentRoutingWithDefaults };\n//# sourceMappingURL=router.js.map\n","/**\n * Polyfill for the optional chain operator, `?.`, given previous conversion of the expression into an array of values,\n * descriptors, and functions.\n *\n * Adapted from Sucrase (https://github.com/alangpierce/sucrase)\n * See https://github.com/alangpierce/sucrase/blob/265887868966917f3b924ce38dfad01fbab1329f/src/transformers/OptionalChainingNullishTransformer.ts#L15\n *\n * @param ops Array result of expression conversion\n * @returns The value of the expression\n */\nfunction _optionalChain(ops) {\n  let lastAccessLHS = undefined;\n  let value = ops[0];\n  let i = 1;\n  while (i < ops.length) {\n    const op = ops[i] ;\n    const fn = ops[i + 1] ;\n    i += 2;\n    // by checking for loose equality to `null`, we catch both `null` and `undefined`\n    if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {\n      // really we're meaning to return `undefined` as an actual value here, but it saves bytes not to write it\n      return;\n    }\n    if (op === 'access' || op === 'optionalAccess') {\n      lastAccessLHS = value;\n      value = fn(value);\n    } else if (op === 'call' || op === 'optionalCall') {\n      value = fn((...args) => (value ).call(lastAccessLHS, ...args));\n      lastAccessLHS = undefined;\n    }\n  }\n  return value;\n}\n\n// Sucrase version\n// function _optionalChain(ops) {\n//   let lastAccessLHS = undefined;\n//   let value = ops[0];\n//   let i = 1;\n//   while (i < ops.length) {\n//     const op = ops[i];\n//     const fn = ops[i + 1];\n//     i += 2;\n//     if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {\n//       return undefined;\n//     }\n//     if (op === 'access' || op === 'optionalAccess') {\n//       lastAccessLHS = value;\n//       value = fn(value);\n//     } else if (op === 'call' || op === 'optionalCall') {\n//       value = fn((...args) => value.call(lastAccessLHS, ...args));\n//       lastAccessLHS = undefined;\n//     }\n//   }\n//   return value;\n// }\n\nexport { _optionalChain };\n//# sourceMappingURL=_optionalChain.js.map\n","import { logger } from '@sentry/utils';\nimport { getActiveTransaction } from '../utils.js';\nimport { WINDOW } from './types.js';\n\n/**\n * Add a listener that cancels and finishes a transaction when the global\n * document is hidden.\n */\nfunction registerBackgroundTabDetection() {\n  if (WINDOW && WINDOW.document) {\n    WINDOW.document.addEventListener('visibilitychange', () => {\n      const activeTransaction = getActiveTransaction() ;\n      if (WINDOW.document.hidden && activeTransaction) {\n        const statusType = 'cancelled';\n\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n          logger.log(\n            `[Tracing] Transaction: ${statusType} -> since tab moved to the background, op: ${activeTransaction.op}`,\n          );\n        // We should not set status if it is already set, this prevent important statuses like\n        // error or data loss from being overwritten on transaction.\n        if (!activeTransaction.status) {\n          activeTransaction.setStatus(statusType);\n        }\n        activeTransaction.setTag('visibilitychange', 'document.hidden');\n        activeTransaction.finish();\n      }\n    });\n  } else {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn('[Tracing] Could not set up background tab detection due to lack of global document');\n  }\n}\n\nexport { registerBackgroundTabDetection };\n//# sourceMappingURL=backgroundtab.js.map\n","import { addExtensionMethods } from './hubextensions.js';\nexport { addExtensionMethods, startIdleTransaction } from './hubextensions.js';\nimport * as index from './integrations/index.js';\nexport { index as Integrations };\nimport './browser/index.js';\nexport { Span, spanStatusfromHttpCode } from './span.js';\nexport { SpanStatus } from './spanstatus.js';\nexport { Transaction } from './transaction.js';\nexport { IdleTransaction } from './idletransaction.js';\nexport { getActiveTransaction, hasTracingEnabled } from './utils.js';\nexport { BROWSER_TRACING_INTEGRATION_ID, BrowserTracing } from './browser/browsertracing.js';\nexport { defaultRequestInstrumentationOptions, instrumentOutgoingRequests } from './browser/request.js';\nexport { TRACEPARENT_REGEXP, extractTraceparentData, stripUrlQueryAndFragment } from '@sentry/utils';\n\n;\n;\n\n// Treeshakable guard to remove all code related to tracing\n\n// Guard for tree\nif (typeof __SENTRY_TRACING__ === 'undefined' || __SENTRY_TRACING__) {\n  // We are patching the global object with our hub extension methods\n  addExtensionMethods();\n}\n//# sourceMappingURL=index.js.map\n","import { _nullishCoalesce } from '@sentry/utils/esm/buildPolyfills';\nimport { uuid4, timestampWithMs, logger, dropUndefinedKeys } from '@sentry/utils';\n\n/**\n * Keeps track of finished spans for a given transaction\n * @internal\n * @hideconstructor\n * @hidden\n */\nclass SpanRecorder {\n   __init() {this.spans = [];}\n\n   constructor(maxlen = 1000) {;SpanRecorder.prototype.__init.call(this);\n    this._maxlen = maxlen;\n  }\n\n  /**\n   * This is just so that we don't run out of memory while recording a lot\n   * of spans. At some point we just stop and flush out the start of the\n   * trace tree (i.e.the first n spans with the smallest\n   * start_timestamp).\n   */\n   add(span) {\n    if (this.spans.length > this._maxlen) {\n      span.spanRecorder = undefined;\n    } else {\n      this.spans.push(span);\n    }\n  }\n}\n\n/**\n * Span contains all data about a span\n */\nclass Span  {\n  /**\n   * @inheritDoc\n   */\n   __init2() {this.traceId = uuid4();}\n\n  /**\n   * @inheritDoc\n   */\n   __init3() {this.spanId = uuid4().substring(16);}\n\n  /**\n   * @inheritDoc\n   */\n\n  /**\n   * Internal keeper of the status\n   */\n\n  /**\n   * @inheritDoc\n   */\n\n  /**\n   * Timestamp in seconds when the span was created.\n   */\n   __init4() {this.startTimestamp = timestampWithMs();}\n\n  /**\n   * Timestamp in seconds when the span ended.\n   */\n\n  /**\n   * @inheritDoc\n   */\n\n  /**\n   * @inheritDoc\n   */\n\n  /**\n   * @inheritDoc\n   */\n   __init5() {this.tags = {};}\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n   __init6() {this.data = {};}\n\n  /**\n   * List of spans that were finalized\n   */\n\n  /**\n   * @inheritDoc\n   */\n\n  /**\n   * You should never call the constructor manually, always use `Sentry.startTransaction()`\n   * or call `startChild()` on an existing span.\n   * @internal\n   * @hideconstructor\n   * @hidden\n   */\n   constructor(spanContext) {;Span.prototype.__init2.call(this);Span.prototype.__init3.call(this);Span.prototype.__init4.call(this);Span.prototype.__init5.call(this);Span.prototype.__init6.call(this);\n    if (!spanContext) {\n      return this;\n    }\n    if (spanContext.traceId) {\n      this.traceId = spanContext.traceId;\n    }\n    if (spanContext.spanId) {\n      this.spanId = spanContext.spanId;\n    }\n    if (spanContext.parentSpanId) {\n      this.parentSpanId = spanContext.parentSpanId;\n    }\n    // We want to include booleans as well here\n    if ('sampled' in spanContext) {\n      this.sampled = spanContext.sampled;\n    }\n    if (spanContext.op) {\n      this.op = spanContext.op;\n    }\n    if (spanContext.description) {\n      this.description = spanContext.description;\n    }\n    if (spanContext.data) {\n      this.data = spanContext.data;\n    }\n    if (spanContext.tags) {\n      this.tags = spanContext.tags;\n    }\n    if (spanContext.status) {\n      this.status = spanContext.status;\n    }\n    if (spanContext.startTimestamp) {\n      this.startTimestamp = spanContext.startTimestamp;\n    }\n    if (spanContext.endTimestamp) {\n      this.endTimestamp = spanContext.endTimestamp;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   startChild(\n    spanContext,\n  ) {\n    const childSpan = new Span({\n      ...spanContext,\n      parentSpanId: this.spanId,\n      sampled: this.sampled,\n      traceId: this.traceId,\n    });\n\n    childSpan.spanRecorder = this.spanRecorder;\n    if (childSpan.spanRecorder) {\n      childSpan.spanRecorder.add(childSpan);\n    }\n\n    childSpan.transaction = this.transaction;\n\n    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && childSpan.transaction) {\n      const opStr = (spanContext && spanContext.op) || '< unknown op >';\n      const nameStr = childSpan.transaction.name || '< unknown name >';\n      const idStr = childSpan.transaction.spanId;\n\n      const logMessage = `[Tracing] Starting '${opStr}' span on transaction '${nameStr}' (${idStr}).`;\n      childSpan.transaction.metadata.spanMetadata[childSpan.spanId] = { logMessage };\n      logger.log(logMessage);\n    }\n\n    return childSpan;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setTag(key, value) {\n    this.tags = { ...this.tags, [key]: value };\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n   setData(key, value) {\n    this.data = { ...this.data, [key]: value };\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setStatus(value) {\n    this.status = value;\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setHttpStatus(httpStatus) {\n    this.setTag('http.status_code', String(httpStatus));\n    const spanStatus = spanStatusfromHttpCode(httpStatus);\n    if (spanStatus !== 'unknown_error') {\n      this.setStatus(spanStatus);\n    }\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   isSuccess() {\n    return this.status === 'ok';\n  }\n\n  /**\n   * @inheritDoc\n   */\n   finish(endTimestamp) {\n    if (\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      // Don't call this for transactions\n      this.transaction &&\n      this.transaction.spanId !== this.spanId\n    ) {\n      const { logMessage } = this.transaction.metadata.spanMetadata[this.spanId];\n      if (logMessage) {\n        logger.log((logMessage ).replace('Starting', 'Finishing'));\n      }\n    }\n\n    this.endTimestamp = typeof endTimestamp === 'number' ? endTimestamp : timestampWithMs();\n  }\n\n  /**\n   * @inheritDoc\n   */\n   toTraceparent() {\n    let sampledString = '';\n    if (this.sampled !== undefined) {\n      sampledString = this.sampled ? '-1' : '-0';\n    }\n    return `${this.traceId}-${this.spanId}${sampledString}`;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   toContext() {\n    return dropUndefinedKeys({\n      data: this.data,\n      description: this.description,\n      endTimestamp: this.endTimestamp,\n      op: this.op,\n      parentSpanId: this.parentSpanId,\n      sampled: this.sampled,\n      spanId: this.spanId,\n      startTimestamp: this.startTimestamp,\n      status: this.status,\n      tags: this.tags,\n      traceId: this.traceId,\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n   updateWithContext(spanContext) {\n    this.data = _nullishCoalesce(spanContext.data, () => ( {}));\n    this.description = spanContext.description;\n    this.endTimestamp = spanContext.endTimestamp;\n    this.op = spanContext.op;\n    this.parentSpanId = spanContext.parentSpanId;\n    this.sampled = spanContext.sampled;\n    this.spanId = _nullishCoalesce(spanContext.spanId, () => ( this.spanId));\n    this.startTimestamp = _nullishCoalesce(spanContext.startTimestamp, () => ( this.startTimestamp));\n    this.status = spanContext.status;\n    this.tags = _nullishCoalesce(spanContext.tags, () => ( {}));\n    this.traceId = _nullishCoalesce(spanContext.traceId, () => ( this.traceId));\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getTraceContext()\n\n {\n    return dropUndefinedKeys({\n      data: Object.keys(this.data).length > 0 ? this.data : undefined,\n      description: this.description,\n      op: this.op,\n      parent_span_id: this.parentSpanId,\n      span_id: this.spanId,\n      status: this.status,\n      tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,\n      trace_id: this.traceId,\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n   toJSON()\n\n {\n    return dropUndefinedKeys({\n      data: Object.keys(this.data).length > 0 ? this.data : undefined,\n      description: this.description,\n      op: this.op,\n      parent_span_id: this.parentSpanId,\n      span_id: this.spanId,\n      start_timestamp: this.startTimestamp,\n      status: this.status,\n      tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,\n      timestamp: this.endTimestamp,\n      trace_id: this.traceId,\n    });\n  }\n}\n\n/**\n * Converts a HTTP status code into a {@link SpanStatusType}.\n *\n * @param httpStatus The HTTP response status code.\n * @returns The span status or unknown_error.\n */\nfunction spanStatusfromHttpCode(httpStatus) {\n  if (httpStatus < 400 && httpStatus >= 100) {\n    return 'ok';\n  }\n\n  if (httpStatus >= 400 && httpStatus < 500) {\n    switch (httpStatus) {\n      case 401:\n        return 'unauthenticated';\n      case 403:\n        return 'permission_denied';\n      case 404:\n        return 'not_found';\n      case 409:\n        return 'already_exists';\n      case 413:\n        return 'failed_precondition';\n      case 429:\n        return 'resource_exhausted';\n      default:\n        return 'invalid_argument';\n    }\n  }\n\n  if (httpStatus >= 500 && httpStatus < 600) {\n    switch (httpStatus) {\n      case 501:\n        return 'unimplemented';\n      case 503:\n        return 'unavailable';\n      case 504:\n        return 'deadline_exceeded';\n      default:\n        return 'internal_error';\n    }\n  }\n\n  return 'unknown_error';\n}\n\nexport { Span, SpanRecorder, spanStatusfromHttpCode };\n//# sourceMappingURL=span.js.map\n","import { _nullishCoalesce } from '@sentry/utils/esm/buildPolyfills';\nimport { getCurrentHub } from '@sentry/core';\nimport { timestampInSeconds, logger, dropUndefinedKeys } from '@sentry/utils';\nimport { Span, SpanRecorder } from './span.js';\n\n/** JSDoc */\nclass Transaction extends Span  {\n\n  /**\n   * The reference to the current hub.\n   */\n\n   __init() {this._measurements = {};}\n\n   __init2() {this._frozenDynamicSamplingContext = undefined;}\n\n  /**\n   * This constructor should never be called manually. Those instrumenting tracing should use\n   * `Sentry.startTransaction()`, and internal methods should use `hub.startTransaction()`.\n   * @internal\n   * @hideconstructor\n   * @hidden\n   */\n   constructor(transactionContext, hub) {\n    super(transactionContext);Transaction.prototype.__init.call(this);Transaction.prototype.__init2.call(this);;\n\n    this._hub = hub || getCurrentHub();\n\n    this._name = transactionContext.name || '';\n\n    this.metadata = {\n      source: 'custom',\n      ...transactionContext.metadata,\n      spanMetadata: {},\n      changes: [],\n      propagations: 0,\n    };\n\n    this._trimEnd = transactionContext.trimEnd;\n\n    // this is because transactions are also spans, and spans have a transaction pointer\n    this.transaction = this;\n\n    // If Dynamic Sampling Context is provided during the creation of the transaction, we freeze it as it usually means\n    // there is incoming Dynamic Sampling Context. (Either through an incoming request, a baggage meta-tag, or other means)\n    const incomingDynamicSamplingContext = this.metadata.dynamicSamplingContext;\n    if (incomingDynamicSamplingContext) {\n      // We shallow copy this in case anything writes to the original reference of the passed in `dynamicSamplingContext`\n      this._frozenDynamicSamplingContext = { ...incomingDynamicSamplingContext };\n    }\n  }\n\n  /** Getter for `name` property */\n   get name() {\n    return this._name;\n  }\n\n  /** Setter for `name` property, which also sets `source` as custom */\n   set name(newName) {\n    this.setName(newName);\n  }\n\n  /**\n   * JSDoc\n   */\n   setName(name, source = 'custom') {\n    // `source` could change without the name changing if we discover that an unparameterized route is actually\n    // parameterized by virtue of having no parameters in its path\n    if (name !== this.name || source !== this.metadata.source) {\n      this.metadata.changes.push({\n        // log previous source\n        source: this.metadata.source,\n        timestamp: timestampInSeconds(),\n        propagations: this.metadata.propagations,\n      });\n    }\n\n    this._name = name;\n    this.metadata.source = source;\n  }\n\n  /**\n   * Attaches SpanRecorder to the span itself\n   * @param maxlen maximum number of spans that can be recorded\n   */\n   initSpanRecorder(maxlen = 1000) {\n    if (!this.spanRecorder) {\n      this.spanRecorder = new SpanRecorder(maxlen);\n    }\n    this.spanRecorder.add(this);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setMeasurement(name, value, unit = '') {\n    this._measurements[name] = { value, unit };\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setMetadata(newMetadata) {\n    this.metadata = { ...this.metadata, ...newMetadata };\n  }\n\n  /**\n   * @inheritDoc\n   */\n   finish(endTimestamp) {\n    // This transaction is already finished, so we should not flush it again.\n    if (this.endTimestamp !== undefined) {\n      return undefined;\n    }\n\n    if (!this.name) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Transaction has no name, falling back to `<unlabeled transaction>`.');\n      this.name = '<unlabeled transaction>';\n    }\n\n    // just sets the end timestamp\n    super.finish(endTimestamp);\n\n    if (this.sampled !== true) {\n      // At this point if `sampled !== true` we want to discard the transaction.\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Tracing] Discarding transaction because its trace was not chosen to be sampled.');\n\n      const client = this._hub.getClient();\n      if (client) {\n        client.recordDroppedEvent('sample_rate', 'transaction');\n      }\n\n      return undefined;\n    }\n\n    const finishedSpans = this.spanRecorder ? this.spanRecorder.spans.filter(s => s !== this && s.endTimestamp) : [];\n\n    if (this._trimEnd && finishedSpans.length > 0) {\n      this.endTimestamp = finishedSpans.reduce((prev, current) => {\n        if (prev.endTimestamp && current.endTimestamp) {\n          return prev.endTimestamp > current.endTimestamp ? prev : current;\n        }\n        return prev;\n      }).endTimestamp;\n    }\n\n    const metadata = this.metadata;\n\n    const transaction = {\n      contexts: {\n        trace: this.getTraceContext(),\n      },\n      spans: finishedSpans,\n      start_timestamp: this.startTimestamp,\n      tags: this.tags,\n      timestamp: this.endTimestamp,\n      transaction: this.name,\n      type: 'transaction',\n      sdkProcessingMetadata: {\n        ...metadata,\n        dynamicSamplingContext: this.getDynamicSamplingContext(),\n      },\n      ...(metadata.source && {\n        transaction_info: {\n          source: metadata.source,\n          changes: metadata.changes,\n          propagations: metadata.propagations,\n        },\n      }),\n    };\n\n    const hasMeasurements = Object.keys(this._measurements).length > 0;\n\n    if (hasMeasurements) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.log(\n          '[Measurements] Adding measurements to transaction',\n          JSON.stringify(this._measurements, undefined, 2),\n        );\n      transaction.measurements = this._measurements;\n    }\n\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log(`[Tracing] Finishing ${this.op} transaction: ${this.name}.`);\n\n    return this._hub.captureEvent(transaction);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   toContext() {\n    const spanContext = super.toContext();\n\n    return dropUndefinedKeys({\n      ...spanContext,\n      name: this.name,\n      trimEnd: this._trimEnd,\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n   updateWithContext(transactionContext) {\n    super.updateWithContext(transactionContext);\n\n    this.name = _nullishCoalesce(transactionContext.name, () => ( ''));\n\n    this._trimEnd = transactionContext.trimEnd;\n\n    return this;\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * @experimental\n   */\n   getDynamicSamplingContext() {\n    if (this._frozenDynamicSamplingContext) {\n      return this._frozenDynamicSamplingContext;\n    }\n\n    const hub = this._hub || getCurrentHub();\n    const client = hub && hub.getClient();\n\n    if (!client) return {};\n\n    const { environment, release } = client.getOptions() || {};\n    const { publicKey: public_key } = client.getDsn() || {};\n\n    const maybeSampleRate = this.metadata.sampleRate;\n    const sample_rate = maybeSampleRate !== undefined ? maybeSampleRate.toString() : undefined;\n\n    const scope = hub.getScope();\n    const { segment: user_segment } = (scope && scope.getUser()) || {};\n\n    const source = this.metadata.source;\n\n    // We don't want to have a transaction name in the DSC if the source is \"url\" because URLs might contain PII\n    const transaction = source && source !== 'url' ? this.name : undefined;\n\n    const dsc = dropUndefinedKeys({\n      environment,\n      release,\n      transaction,\n      user_segment,\n      public_key,\n      trace_id: this.traceId,\n      sample_rate,\n    });\n\n    // Uncomment if we want to make DSC immutable\n    // this._frozenDynamicSamplingContext = dsc;\n\n    return dsc;\n  }\n}\n\nexport { Transaction };\n//# sourceMappingURL=transaction.js.map\n","import { getCurrentHub } from '@sentry/core';\nexport { TRACEPARENT_REGEXP, extractTraceparentData, stripUrlQueryAndFragment } from '@sentry/utils';\n\n/**\n * Determines if tracing is currently enabled.\n *\n * Tracing is enabled when at least one of `tracesSampleRate` and `tracesSampler` is defined in the SDK config.\n */\nfunction hasTracingEnabled(\n  maybeOptions,\n) {\n  const client = getCurrentHub().getClient();\n  const options = maybeOptions || (client && client.getOptions());\n  return !!options && ('tracesSampleRate' in options || 'tracesSampler' in options);\n}\n\n/** Grabs active transaction off scope, if any */\nfunction getActiveTransaction(maybeHub) {\n  const hub = maybeHub || getCurrentHub();\n  const scope = hub.getScope();\n  return scope && (scope.getTransaction() );\n}\n\n/**\n * Converts from milliseconds to seconds\n * @param time time in ms\n */\nfunction msToSec(time) {\n  return time / 1000;\n}\n\n/**\n * Converts from seconds to milliseconds\n * @param time time in seconds\n */\nfunction secToMs(time) {\n  return time * 1000;\n}\n\nexport { getActiveTransaction, hasTracingEnabled, msToSec, secToMs };\n//# sourceMappingURL=utils.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\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(elem, keyAttrs) {\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 MAX_OUTPUT_LEN = 80;\n    const out = [];\n    let height = 0;\n    let len = 0;\n    const separator = ' > ';\n    const sepLength = separator.length;\n    let nextStr;\n\n    // eslint-disable-next-line no-plusplus\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 MAX_OUTPUT_LEN\n      //   (ignore this limit if we are on the first iteration)\n      if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= MAX_OUTPUT_LEN)) {\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 = ['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 * Polyfill for the nullish coalescing operator (`??`).\n *\n * Note that the RHS is wrapped in a function so that if it's a computed value, that evaluation won't happen unless the\n * LHS evaluates to a nullish value, to mimic the operator's short-circuiting behavior.\n *\n * Adapted from Sucrase (https://github.com/alangpierce/sucrase)\n *\n * @param lhs The value of the expression to the left of the `??`\n * @param rhsFn A function returning the value of the expression to the right of the `??`\n * @returns The LHS value, unless it's `null` or `undefined`, in which case, the RHS value\n */\nfunction _nullishCoalesce(lhs, rhsFn) {\n  // by checking for loose equality to `null`, we catch both `null` and `undefined`\n  return lhs != null ? lhs : rhsFn();\n}\n\n// Sucrase version:\n// function _nullishCoalesce(lhs, rhsFn) {\n//   if (lhs != null) {\n//     return lhs;\n//   } else {\n//     return rhsFn();\n//   }\n// }\n\nexport { _nullishCoalesce };\n//# sourceMappingURL=_nullishCoalesce.js.map\n","import { isInstanceOf, isString } from './is.js';\nimport { logger, CONSOLE_LEVELS } from './logger.js';\nimport { fill } from './object.js';\nimport { getFunctionName } from './stacktrace.js';\nimport { supportsNativeFetch, supportsHistory } from './supports.js';\nimport { getGlobalObject } from './worldwide.js';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject();\n\n/**\n * Instrument native APIs to call handlers that can be used to create breadcrumbs, APM spans etc.\n *  - Console API\n *  - Fetch API\n *  - XHR API\n *  - History API\n *  - DOM API (click/typing)\n *  - Error API\n *  - UnhandledRejection API\n */\n\nconst handlers = {};\nconst instrumented = {};\n\n/** Instruments given API */\nfunction instrument(type) {\n  if (instrumented[type]) {\n    return;\n  }\n\n  instrumented[type] = true;\n\n  switch (type) {\n    case 'console':\n      instrumentConsole();\n      break;\n    case 'dom':\n      instrumentDOM();\n      break;\n    case 'xhr':\n      instrumentXHR();\n      break;\n    case 'fetch':\n      instrumentFetch();\n      break;\n    case 'history':\n      instrumentHistory();\n      break;\n    case 'error':\n      instrumentError();\n      break;\n    case 'unhandledrejection':\n      instrumentUnhandledRejection();\n      break;\n    default:\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('unknown instrumentation type:', type);\n      return;\n  }\n}\n\n/**\n * Add handler that will be called when given type of instrumentation triggers.\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addInstrumentationHandler(type, callback) {\n  handlers[type] = handlers[type] || [];\n  (handlers[type] ).push(callback);\n  instrument(type);\n}\n\n/** JSDoc */\nfunction triggerHandlers(type, data) {\n  if (!type || !handlers[type]) {\n    return;\n  }\n\n  for (const handler of handlers[type] || []) {\n    try {\n      handler(data);\n    } catch (e) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.error(\n          `Error while triggering instrumentation handler.\\nType: ${type}\\nName: ${getFunctionName(handler)}\\nError:`,\n          e,\n        );\n    }\n  }\n}\n\n/** JSDoc */\nfunction instrumentConsole() {\n  if (!('console' in WINDOW)) {\n    return;\n  }\n\n  CONSOLE_LEVELS.forEach(function (level) {\n    if (!(level in WINDOW.console)) {\n      return;\n    }\n\n    fill(WINDOW.console, level, function (originalConsoleMethod) {\n      return function (...args) {\n        triggerHandlers('console', { args, level });\n\n        // this fails for some browsers. :(\n        if (originalConsoleMethod) {\n          originalConsoleMethod.apply(WINDOW.console, args);\n        }\n      };\n    });\n  });\n}\n\n/** JSDoc */\nfunction instrumentFetch() {\n  if (!supportsNativeFetch()) {\n    return;\n  }\n\n  fill(WINDOW, 'fetch', function (originalFetch) {\n    return function (...args) {\n      const handlerData = {\n        args,\n        fetchData: {\n          method: getFetchMethod(args),\n          url: getFetchUrl(args),\n        },\n        startTimestamp: Date.now(),\n      };\n\n      triggerHandlers('fetch', {\n        ...handlerData,\n      });\n\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      return originalFetch.apply(WINDOW, args).then(\n        (response) => {\n          triggerHandlers('fetch', {\n            ...handlerData,\n            endTimestamp: Date.now(),\n            response,\n          });\n          return response;\n        },\n        (error) => {\n          triggerHandlers('fetch', {\n            ...handlerData,\n            endTimestamp: Date.now(),\n            error,\n          });\n          // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n          //       it means the sentry.javascript SDK caught an error invoking your application code.\n          //       This is expected behavior and NOT indicative of a bug with sentry.javascript.\n          throw error;\n        },\n      );\n    };\n  });\n}\n\n/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/** Extract `method` from fetch call arguments */\nfunction getFetchMethod(fetchArgs = []) {\n  if ('Request' in WINDOW && isInstanceOf(fetchArgs[0], Request) && fetchArgs[0].method) {\n    return String(fetchArgs[0].method).toUpperCase();\n  }\n  if (fetchArgs[1] && fetchArgs[1].method) {\n    return String(fetchArgs[1].method).toUpperCase();\n  }\n  return 'GET';\n}\n\n/** Extract `url` from fetch call arguments */\nfunction getFetchUrl(fetchArgs = []) {\n  if (typeof fetchArgs[0] === 'string') {\n    return fetchArgs[0];\n  }\n  if ('Request' in WINDOW && isInstanceOf(fetchArgs[0], Request)) {\n    return fetchArgs[0].url;\n  }\n  return String(fetchArgs[0]);\n}\n/* eslint-enable @typescript-eslint/no-unsafe-member-access */\n\n/** JSDoc */\nfunction instrumentXHR() {\n  if (!('XMLHttpRequest' in WINDOW)) {\n    return;\n  }\n\n  const xhrproto = XMLHttpRequest.prototype;\n\n  fill(xhrproto, 'open', function (originalOpen) {\n    return function ( ...args) {\n      // eslint-disable-next-line @typescript-eslint/no-this-alias\n      const xhr = this;\n      const url = args[1];\n      const xhrInfo = (xhr.__sentry_xhr__ = {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n        method: isString(args[0]) ? args[0].toUpperCase() : args[0],\n        url: args[1],\n      });\n\n      // if Sentry key appears in URL, don't capture it as a request\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      if (isString(url) && xhrInfo.method === 'POST' && url.match(/sentry_key/)) {\n        xhr.__sentry_own_request__ = true;\n      }\n\n      const onreadystatechangeHandler = function () {\n        if (xhr.readyState === 4) {\n          try {\n            // touching statusCode in some platforms throws\n            // an exception\n            xhrInfo.status_code = xhr.status;\n          } catch (e) {\n            /* do nothing */\n          }\n\n          triggerHandlers('xhr', {\n            args,\n            endTimestamp: Date.now(),\n            startTimestamp: Date.now(),\n            xhr,\n          });\n        }\n      };\n\n      if ('onreadystatechange' in xhr && typeof xhr.onreadystatechange === 'function') {\n        fill(xhr, 'onreadystatechange', function (original) {\n          return function (...readyStateArgs) {\n            onreadystatechangeHandler();\n            return original.apply(xhr, readyStateArgs);\n          };\n        });\n      } else {\n        xhr.addEventListener('readystatechange', onreadystatechangeHandler);\n      }\n\n      return originalOpen.apply(xhr, args);\n    };\n  });\n\n  fill(xhrproto, 'send', function (originalSend) {\n    return function ( ...args) {\n      if (this.__sentry_xhr__ && args[0] !== undefined) {\n        this.__sentry_xhr__.body = args[0];\n      }\n\n      triggerHandlers('xhr', {\n        args,\n        startTimestamp: Date.now(),\n        xhr: this,\n      });\n\n      return originalSend.apply(this, args);\n    };\n  });\n}\n\nlet lastHref;\n\n/** JSDoc */\nfunction instrumentHistory() {\n  if (!supportsHistory()) {\n    return;\n  }\n\n  const oldOnPopState = WINDOW.onpopstate;\n  WINDOW.onpopstate = function ( ...args) {\n    const to = WINDOW.location.href;\n    // keep track of the current URL state, as we always receive only the updated state\n    const from = lastHref;\n    lastHref = to;\n    triggerHandlers('history', {\n      from,\n      to,\n    });\n    if (oldOnPopState) {\n      // Apparently this can throw in Firefox when incorrectly implemented plugin is installed.\n      // https://github.com/getsentry/sentry-javascript/issues/3344\n      // https://github.com/bugsnag/bugsnag-js/issues/469\n      try {\n        return oldOnPopState.apply(this, args);\n      } catch (_oO) {\n        // no-empty\n      }\n    }\n  };\n\n  /** @hidden */\n  function historyReplacementFunction(originalHistoryFunction) {\n    return function ( ...args) {\n      const url = args.length > 2 ? args[2] : undefined;\n      if (url) {\n        // coerce to string (this is what pushState does)\n        const from = lastHref;\n        const to = String(url);\n        // keep track of the current URL state, as we always receive only the updated state\n        lastHref = to;\n        triggerHandlers('history', {\n          from,\n          to,\n        });\n      }\n      return originalHistoryFunction.apply(this, args);\n    };\n  }\n\n  fill(WINDOW.history, 'pushState', historyReplacementFunction);\n  fill(WINDOW.history, 'replaceState', historyReplacementFunction);\n}\n\nconst debounceDuration = 1000;\nlet debounceTimerID;\nlet lastCapturedEvent;\n\n/**\n * Decide whether the current event should finish the debounce of previously captured one.\n * @param previous previously captured event\n * @param current event to be captured\n */\nfunction shouldShortcircuitPreviousDebounce(previous, current) {\n  // If there was no previous event, it should always be swapped for the new one.\n  if (!previous) {\n    return true;\n  }\n\n  // If both events have different type, then user definitely performed two separate actions. e.g. click + keypress.\n  if (previous.type !== current.type) {\n    return true;\n  }\n\n  try {\n    // If both events have the same type, it's still possible that actions were performed on different targets.\n    // e.g. 2 clicks on different buttons.\n    if (previous.target !== current.target) {\n      return true;\n    }\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n  }\n\n  // If both events have the same type _and_ same `target` (an element which triggered an event, _not necessarily_\n  // to which an event listener was attached), we treat them as the same action, as we want to capture\n  // only one breadcrumb. e.g. multiple clicks on the same button, or typing inside a user input box.\n  return false;\n}\n\n/**\n * Decide whether an event should be captured.\n * @param event event to be captured\n */\nfunction shouldSkipDOMEvent(event) {\n  // We are only interested in filtering `keypress` events for now.\n  if (event.type !== 'keypress') {\n    return false;\n  }\n\n  try {\n    const target = event.target ;\n\n    if (!target || !target.tagName) {\n      return true;\n    }\n\n    // Only consider keypress events on actual input elements. This will disregard keypresses targeting body\n    // e.g.tabbing through elements, hotkeys, etc.\n    if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {\n      return false;\n    }\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n  }\n\n  return true;\n}\n\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n * @param handler function that will be triggered\n * @param globalListener indicates whether event was captured by the global event listener\n * @returns wrapped breadcrumb events handler\n * @hidden\n */\nfunction makeDOMEventHandler(handler, globalListener = false) {\n  return (event) => {\n    // It's possible this handler might trigger multiple times for the same\n    // event (e.g. event propagation through node ancestors).\n    // Ignore if we've already captured that event.\n    if (!event || lastCapturedEvent === event) {\n      return;\n    }\n\n    // We always want to skip _some_ events.\n    if (shouldSkipDOMEvent(event)) {\n      return;\n    }\n\n    const name = event.type === 'keypress' ? 'input' : event.type;\n\n    // If there is no debounce timer, it means that we can safely capture the new event and store it for future comparisons.\n    if (debounceTimerID === undefined) {\n      handler({\n        event: event,\n        name,\n        global: globalListener,\n      });\n      lastCapturedEvent = event;\n    }\n    // If there is a debounce awaiting, see if the new event is different enough to treat it as a unique one.\n    // If that's the case, emit the previous event and store locally the newly-captured DOM event.\n    else if (shouldShortcircuitPreviousDebounce(lastCapturedEvent, event)) {\n      handler({\n        event: event,\n        name,\n        global: globalListener,\n      });\n      lastCapturedEvent = event;\n    }\n\n    // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.\n    clearTimeout(debounceTimerID);\n    debounceTimerID = WINDOW.setTimeout(() => {\n      debounceTimerID = undefined;\n    }, debounceDuration);\n  };\n}\n\n/** JSDoc */\nfunction instrumentDOM() {\n  if (!('document' in WINDOW)) {\n    return;\n  }\n\n  // Make it so that any click or keypress that is unhandled / bubbled up all the way to the document triggers our dom\n  // handlers. (Normally we have only one, which captures a breadcrumb for each click or keypress.) Do this before\n  // we instrument `addEventListener` so that we don't end up attaching this handler twice.\n  const triggerDOMHandler = triggerHandlers.bind(null, 'dom');\n  const globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);\n  WINDOW.document.addEventListener('click', globalDOMEventHandler, false);\n  WINDOW.document.addEventListener('keypress', globalDOMEventHandler, false);\n\n  // After hooking into click and keypress events bubbled up to `document`, we also hook into user-handled\n  // clicks & keypresses, by adding an event listener of our own to any element to which they add a listener. That\n  // way, whenever one of their handlers is triggered, ours will be, too. (This is needed because their handler\n  // could potentially prevent the event from bubbling up to our global listeners. This way, our handler are still\n  // guaranteed to fire at least once.)\n  ['EventTarget', 'Node'].forEach((target) => {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    const proto = (WINDOW )[target] && (WINDOW )[target].prototype;\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins\n    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n      return;\n    }\n\n    fill(proto, 'addEventListener', function (originalAddEventListener) {\n      return function (\n\n        type,\n        listener,\n        options,\n      ) {\n        if (type === 'click' || type == 'keypress') {\n          try {\n            const el = this ;\n            const handlers = (el.__sentry_instrumentation_handlers__ = el.__sentry_instrumentation_handlers__ || {});\n            const handlerForType = (handlers[type] = handlers[type] || { refCount: 0 });\n\n            if (!handlerForType.handler) {\n              const handler = makeDOMEventHandler(triggerDOMHandler);\n              handlerForType.handler = handler;\n              originalAddEventListener.call(this, type, handler, options);\n            }\n\n            handlerForType.refCount += 1;\n          } catch (e) {\n            // Accessing dom properties is always fragile.\n            // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n          }\n        }\n\n        return originalAddEventListener.call(this, type, listener, options);\n      };\n    });\n\n    fill(\n      proto,\n      'removeEventListener',\n      function (originalRemoveEventListener) {\n        return function (\n\n          type,\n          listener,\n          options,\n        ) {\n          if (type === 'click' || type == 'keypress') {\n            try {\n              const el = this ;\n              const handlers = el.__sentry_instrumentation_handlers__ || {};\n              const handlerForType = handlers[type];\n\n              if (handlerForType) {\n                handlerForType.refCount -= 1;\n                // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.\n                if (handlerForType.refCount <= 0) {\n                  originalRemoveEventListener.call(this, type, handlerForType.handler, options);\n                  handlerForType.handler = undefined;\n                  delete handlers[type]; // eslint-disable-line @typescript-eslint/no-dynamic-delete\n                }\n\n                // If there are no longer any custom handlers of any type on this element, cleanup everything.\n                if (Object.keys(handlers).length === 0) {\n                  delete el.__sentry_instrumentation_handlers__;\n                }\n              }\n            } catch (e) {\n              // Accessing dom properties is always fragile.\n              // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n            }\n          }\n\n          return originalRemoveEventListener.call(this, type, listener, options);\n        };\n      },\n    );\n  });\n}\n\nlet _oldOnErrorHandler = null;\n/** JSDoc */\nfunction instrumentError() {\n  _oldOnErrorHandler = WINDOW.onerror;\n\n  WINDOW.onerror = function (msg, url, line, column, error) {\n    triggerHandlers('error', {\n      column,\n      error,\n      line,\n      msg,\n      url,\n    });\n\n    if (_oldOnErrorHandler) {\n      // eslint-disable-next-line prefer-rest-params\n      return _oldOnErrorHandler.apply(this, arguments);\n    }\n\n    return false;\n  };\n}\n\nlet _oldOnUnhandledRejectionHandler = null;\n/** JSDoc */\nfunction instrumentUnhandledRejection() {\n  _oldOnUnhandledRejectionHandler = WINDOW.onunhandledrejection;\n\n  WINDOW.onunhandledrejection = function (e) {\n    triggerHandlers('unhandledrejection', e);\n\n    if (_oldOnUnhandledRejectionHandler) {\n      // eslint-disable-next-line prefer-rest-params\n      return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n    }\n\n    return true;\n  };\n}\n\nexport { addInstrumentationHandler };\n//# sourceMappingURL=instrument.js.map\n","// eslint-disable-next-line @typescript-eslint/unbound-method\nconst objectToString = Object.prototype.toString;\n\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isError(wat) {\n  switch (objectToString.call(wat)) {\n    case '[object Error]':\n    case '[object Exception]':\n    case '[object DOMException]':\n      return true;\n    default:\n      return isInstanceOf(wat, Error);\n  }\n}\n/**\n * Checks whether given value is an instance of the given built-in class.\n *\n * @param wat The value to be checked\n * @param className\n * @returns A boolean representing the result.\n */\nfunction isBuiltin(wat, className) {\n  return objectToString.call(wat) === `[object ${className}]`;\n}\n\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isErrorEvent(wat) {\n  return isBuiltin(wat, 'ErrorEvent');\n}\n\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isDOMError(wat) {\n  return isBuiltin(wat, 'DOMError');\n}\n\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isDOMException(wat) {\n  return isBuiltin(wat, 'DOMException');\n}\n\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isString(wat) {\n  return isBuiltin(wat, 'String');\n}\n\n/**\n * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isPrimitive(wat) {\n  return wat === null || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n\n/**\n * Checks whether given value's type is an object literal\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isPlainObject(wat) {\n  return isBuiltin(wat, 'Object');\n}\n\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isEvent(wat) {\n  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isElement(wat) {\n  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isRegExp(wat) {\n  return isBuiltin(wat, 'RegExp');\n}\n\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nfunction isThenable(wat) {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return Boolean(wat && wat.then && typeof wat.then === 'function');\n}\n\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isSyntheticEvent(wat) {\n  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n\n/**\n * Checks whether given value is NaN\n * {@link isNaN}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isNaN(wat) {\n  return typeof wat === 'number' && wat !== wat;\n}\n\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nfunction isInstanceOf(wat, base) {\n  try {\n    return wat instanceof base;\n  } catch (_e) {\n    return false;\n  }\n}\n\nexport { isDOMError, isDOMException, isElement, isError, isErrorEvent, isEvent, isInstanceOf, isNaN, isPlainObject, isPrimitive, isRegExp, isString, isSyntheticEvent, isThenable };\n//# sourceMappingURL=is.js.map\n","import { GLOBAL_OBJ, getGlobalSingleton } from './worldwide.js';\n\n/** Prefix for logging strings */\nconst PREFIX = 'Sentry Logger ';\n\nconst CONSOLE_LEVELS = ['debug', 'info', 'warn', 'error', 'log', 'assert', 'trace'] ;\n\n/**\n * Temporarily disable sentry console instrumentations.\n *\n * @param callback The function to run against the original `console` messages\n * @returns The results of the callback\n */\nfunction consoleSandbox(callback) {\n  if (!('console' in GLOBAL_OBJ)) {\n    return callback();\n  }\n\n  const originalConsole = GLOBAL_OBJ.console ;\n  const wrappedLevels = {};\n\n  // Restore all wrapped console methods\n  CONSOLE_LEVELS.forEach(level => {\n    // TODO(v7): Remove this check as it's only needed for Node 6\n    const originalWrappedFunc =\n      originalConsole[level] && (originalConsole[level] ).__sentry_original__;\n    if (level in originalConsole && originalWrappedFunc) {\n      wrappedLevels[level] = originalConsole[level] ;\n      originalConsole[level] = originalWrappedFunc ;\n    }\n  });\n\n  try {\n    return callback();\n  } finally {\n    // Revert restoration to wrapped state\n    Object.keys(wrappedLevels).forEach(level => {\n      originalConsole[level] = wrappedLevels[level ];\n    });\n  }\n}\n\nfunction makeLogger() {\n  let enabled = false;\n  const logger = {\n    enable: () => {\n      enabled = true;\n    },\n    disable: () => {\n      enabled = false;\n    },\n  };\n\n  if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n    CONSOLE_LEVELS.forEach(name => {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      logger[name] = (...args) => {\n        if (enabled) {\n          consoleSandbox(() => {\n            GLOBAL_OBJ.console[name](`${PREFIX}[${name}]:`, ...args);\n          });\n        }\n      };\n    });\n  } else {\n    CONSOLE_LEVELS.forEach(name => {\n      logger[name] = () => undefined;\n    });\n  }\n\n  return logger ;\n}\n\n// Ensure we only have a single logger instance, even if multiple versions of @sentry/utils are being used\nlet logger;\nif ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n  logger = getGlobalSingleton('logger', makeLogger);\n} else {\n  logger = makeLogger();\n}\n\nexport { CONSOLE_LEVELS, consoleSandbox, logger };\n//# sourceMappingURL=logger.js.map\n","import { addNonEnumerableProperty } from './object.js';\nimport { snipLine } from './string.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nfunction uuid4() {\n  const gbl = GLOBAL_OBJ ;\n  const crypto = gbl.crypto || gbl.msCrypto;\n\n  if (crypto && crypto.randomUUID) {\n    return crypto.randomUUID().replace(/-/g, '');\n  }\n\n  const getRandomByte =\n    crypto && crypto.getRandomValues ? () => crypto.getRandomValues(new Uint8Array(1))[0] : () => Math.random() * 16;\n\n  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n  // Concatenating the following numbers as strings results in '10000000100040008000100000000000'\n  return (([1e7] ) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>\n    // eslint-disable-next-line no-bitwise\n    ((c ) ^ ((getRandomByte() & 15) >> ((c ) / 4))).toString(16),\n  );\n}\n\nfunction getFirstException(event) {\n  return event.exception && event.exception.values ? event.exception.values[0] : undefined;\n}\n\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nfunction getEventDescription(event) {\n  const { message, event_id: eventId } = event;\n  if (message) {\n    return message;\n  }\n\n  const firstException = getFirstException(event);\n  if (firstException) {\n    if (firstException.type && firstException.value) {\n      return `${firstException.type}: ${firstException.value}`;\n    }\n    return firstException.type || firstException.value || eventId || '<unknown>';\n  }\n  return eventId || '<unknown>';\n}\n\n/**\n * Adds exception values, type and value to an synthetic Exception.\n * @param event The event to modify.\n * @param value Value of the exception.\n * @param type Type of the exception.\n * @hidden\n */\nfunction addExceptionTypeValue(event, value, type) {\n  const exception = (event.exception = event.exception || {});\n  const values = (exception.values = exception.values || []);\n  const firstException = (values[0] = values[0] || {});\n  if (!firstException.value) {\n    firstException.value = value || '';\n  }\n  if (!firstException.type) {\n    firstException.type = type || 'Error';\n  }\n}\n\n/**\n * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.\n *\n * @param event The event to modify.\n * @param newMechanism Mechanism data to add to the event.\n * @hidden\n */\nfunction addExceptionMechanism(event, newMechanism) {\n  const firstException = getFirstException(event);\n  if (!firstException) {\n    return;\n  }\n\n  const defaultMechanism = { type: 'generic', handled: true };\n  const currentMechanism = firstException.mechanism;\n  firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };\n\n  if (newMechanism && 'data' in newMechanism) {\n    const mergedData = { ...(currentMechanism && currentMechanism.data), ...newMechanism.data };\n    firstException.mechanism.data = mergedData;\n  }\n}\n\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nconst SEMVER_REGEXP =\n  /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n\n/**\n * Represents Semantic Versioning object\n */\n\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nfunction parseSemver(input) {\n  const match = input.match(SEMVER_REGEXP) || [];\n  const major = parseInt(match[1], 10);\n  const minor = parseInt(match[2], 10);\n  const patch = parseInt(match[3], 10);\n  return {\n    buildmetadata: match[5],\n    major: isNaN(major) ? undefined : major,\n    minor: isNaN(minor) ? undefined : minor,\n    patch: isNaN(patch) ? undefined : patch,\n    prerelease: match[4],\n  };\n}\n\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nfunction addContextToFrame(lines, frame, linesOfContext = 5) {\n  const lineno = frame.lineno || 0;\n  const maxLines = lines.length;\n  const sourceLine = Math.max(Math.min(maxLines, 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","/*\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 fags 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\nexport { isBrowserBundle };\n//# sourceMappingURL=env.js.map\n","import { htmlTreeAsString } from './browser.js';\nimport { isError, isEvent, isInstanceOf, isElement, isPlainObject, isPrimitive } from './is.js';\nimport { truncate } from './string.js';\n\n/**\n * Replace a method in an object with a wrapped version of itself.\n *\n * @param source An object that contains a method to be wrapped.\n * @param name The name of the method to be wrapped.\n * @param replacementFactory A higher-order function that takes the original version of the given method and returns a\n * wrapped version. Note: The function returned by `replacementFactory` needs to be a non-arrow function, in order to\n * preserve the correct value of `this`, and the original method must be called using `origMethod.call(this, <other\n * args>)` or `origMethod.apply(this, [<other args>])` (rather than being called directly), again to preserve `this`.\n * @returns void\n */\nfunction fill(source, name, replacementFactory) {\n  if (!(name in source)) {\n    return;\n  }\n\n  const original = source[name] ;\n  const wrapped = replacementFactory(original) ;\n\n  // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n  // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n  if (typeof wrapped === 'function') {\n    try {\n      markFunctionWrapped(wrapped, original);\n    } catch (_Oo) {\n      // This can throw if multiple fill happens on a global object like XMLHttpRequest\n      // Fixes https://github.com/getsentry/sentry-javascript/issues/2043\n    }\n  }\n\n  source[name] = wrapped;\n}\n\n/**\n * Defines a non-enumerable property on the given object.\n *\n * @param obj The object on which to set the property\n * @param name The name of the property to be set\n * @param value The value to which to set the property\n */\nfunction addNonEnumerableProperty(obj, name, value) {\n  Object.defineProperty(obj, name, {\n    // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it\n    value: value,\n    writable: true,\n    configurable: true,\n  });\n}\n\n/**\n * Remembers the original function on the wrapped function and\n * patches up the prototype.\n *\n * @param wrapped the wrapper function\n * @param original the original function that gets wrapped\n */\nfunction markFunctionWrapped(wrapped, original) {\n  const proto = original.prototype || {};\n  wrapped.prototype = original.prototype = proto;\n  addNonEnumerableProperty(wrapped, '__sentry_original__', original);\n}\n\n/**\n * This extracts the original function if available.  See\n * `markFunctionWrapped` for more information.\n *\n * @param func the function to unwrap\n * @returns the unwrapped version of the function if available.\n */\nfunction getOriginalFunction(func) {\n  return func.__sentry_original__;\n}\n\n/**\n * Encodes given object into url-friendly format\n *\n * @param object An object that contains serializable values\n * @returns string Encoded\n */\nfunction urlEncode(object) {\n  return Object.keys(object)\n    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(object[key])}`)\n    .join('&');\n}\n\n/**\n * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their\n * non-enumerable properties attached.\n *\n * @param value Initial source that we have to transform in order for it to be usable by the serializer\n * @returns An Event or Error turned into an object - or the value argurment itself, when value is neither an Event nor\n *  an Error.\n */\nfunction convertToPlainObject(\n  value,\n)\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 { _optionalChain } from './buildPolyfills';\n\nconst STACKTRACE_LIMIT = 50;\n\n/**\n * Creates a stack parser with the supplied line parsers\n *\n * StackFrames are returned in the correct order for Sentry Exception\n * frames and with Sentry SDK internal frames removed from the top and bottom\n *\n */\nfunction createStackParser(...parsers) {\n  const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);\n\n  return (stack, skipFirst = 0) => {\n    const frames = [];\n\n    for (const line of stack.split('\\n').slice(skipFirst)) {\n      // https://github.com/getsentry/sentry-javascript/issues/5459\n      // Remove webpack (error: *) wrappers\n      const cleanedLine = line.replace(/\\(error: (.*)\\)/, '$1');\n\n      for (const parser of sortedParsers) {\n        const frame = parser(cleanedLine);\n\n        if (frame) {\n          frames.push(frame);\n          break;\n        }\n      }\n    }\n\n    return stripSentryFramesAndReverse(frames);\n  };\n}\n\n/**\n * Gets a stack parser implementation from Options.stackParser\n * @see Options\n *\n * If options contains an array of line parsers, it is converted into a parser\n */\nfunction stackParserFromStackParserOptions(stackParser) {\n  if (Array.isArray(stackParser)) {\n    return createStackParser(...stackParser);\n  }\n  return stackParser;\n}\n\n/**\n * @hidden\n */\nfunction stripSentryFramesAndReverse(stack) {\n  if (!stack.length) {\n    return [];\n  }\n\n  let localStack = stack;\n\n  const firstFrameFunction = localStack[0].function || '';\n  const lastFrameFunction = localStack[localStack.length - 1].function || '';\n\n  // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n  if (firstFrameFunction.indexOf('captureMessage') !== -1 || firstFrameFunction.indexOf('captureException') !== -1) {\n    localStack = localStack.slice(1);\n  }\n\n  // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)\n  if (lastFrameFunction.indexOf('sentryWrapped') !== -1) {\n    localStack = localStack.slice(0, -1);\n  }\n\n  // The frame where the crash happened, should be the last entry in the array\n  return localStack\n    .slice(0, STACKTRACE_LIMIT)\n    .map(frame => ({\n      ...frame,\n      filename: frame.filename || localStack[0].filename,\n      function: frame.function || '?',\n    }))\n    .reverse();\n}\n\nconst defaultFunctionName = '<anonymous>';\n\n/**\n * Safely extract function name from itself\n */\nfunction getFunctionName(fn) {\n  try {\n    if (!fn || typeof fn !== 'function') {\n      return defaultFunctionName;\n    }\n    return fn.name || defaultFunctionName;\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    return defaultFunctionName;\n  }\n}\n\n// eslint-disable-next-line complexity\nfunction node(getModule) {\n  const FILENAME_MATCH = /^\\s*[-]{4,}$/;\n  const FULL_MATCH = /at (?:async )?(?:(.+?)\\s+\\()?(?:(.+):(\\d+):(\\d+)?|([^)]+))\\)?/;\n\n  // eslint-disable-next-line complexity\n  return (line) => {\n    if (line.match(FILENAME_MATCH)) {\n      return {\n        filename: line,\n      };\n    }\n\n    const lineMatch = line.match(FULL_MATCH);\n    if (!lineMatch) {\n      return undefined;\n    }\n\n    let object;\n    let method;\n    let functionName;\n    let typeName;\n    let methodName;\n\n    if (lineMatch[1]) {\n      functionName = lineMatch[1];\n\n      let methodStart = functionName.lastIndexOf('.');\n      if (functionName[methodStart - 1] === '.') {\n        // eslint-disable-next-line no-plusplus\n        methodStart--;\n      }\n\n      if (methodStart > 0) {\n        object = functionName.substr(0, methodStart);\n        method = functionName.substr(methodStart + 1);\n        const objectEnd = object.indexOf('.Module');\n        if (objectEnd > 0) {\n          functionName = functionName.substr(objectEnd + 1);\n          object = object.substr(0, objectEnd);\n        }\n      }\n      typeName = undefined;\n    }\n\n    if (method) {\n      typeName = object;\n      methodName = method;\n    }\n\n    if (method === '<anonymous>') {\n      methodName = undefined;\n      functionName = undefined;\n    }\n\n    if (functionName === undefined) {\n      methodName = methodName || '<anonymous>';\n      functionName = typeName ? `${typeName}.${methodName}` : methodName;\n    }\n\n    const filename = _optionalChain([lineMatch, 'access', _ => _[2], 'optionalAccess', _2 => _2.startsWith, 'call', _3 => _3('file://')]) ? lineMatch[2].substr(7) : lineMatch[2];\n    const isNative = lineMatch[5] === 'native';\n    const isInternal =\n      isNative || (filename && !filename.startsWith('/') && !filename.startsWith('.') && filename.indexOf(':\\\\') !== 1);\n\n    // in_app is all that's not an internal Node function or a module within node_modules\n    // note that isNative appears to return true even for node core libraries\n    // see https://github.com/getsentry/raven-node/issues/176\n    const in_app = !isInternal && filename !== undefined && !filename.includes('node_modules/');\n\n    return {\n      filename,\n      module: _optionalChain([getModule, 'optionalCall', _4 => _4(filename)]),\n      function: functionName,\n      lineno: parseInt(lineMatch[3], 10) || undefined,\n      colno: parseInt(lineMatch[4], 10) || undefined,\n      in_app,\n    };\n  };\n}\n\n/**\n * Node.js stack line parser\n *\n * This is in @sentry/utils so it can be used from the Electron SDK in the browser for when `nodeIntegration == true`.\n * This allows it to be used without referencing or importing any node specific code which causes bundlers to complain\n */\nfunction nodeStackLineParser(getModule) {\n  return [90, node(getModule)];\n}\n\nexport { createStackParser, getFunctionName, nodeStackLineParser, stackParserFromStackParserOptions, stripSentryFramesAndReverse };\n//# sourceMappingURL=stacktrace.js.map\n","import { isString, isRegExp } from './is.js';\n\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string (0 = unlimited)\n * @returns string Encoded\n */\nfunction truncate(str, max = 0) {\n  if (typeof str !== 'string' || max === 0) {\n    return str;\n  }\n  return str.length <= max ? str : `${str.substr(0, max)}...`;\n}\n\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nfunction snipLine(line, colno) {\n  let newLine = line;\n  const lineLength = newLine.length;\n  if (lineLength <= 150) {\n    return newLine;\n  }\n  if (colno > lineLength) {\n    // eslint-disable-next-line no-param-reassign\n    colno = lineLength;\n  }\n\n  let start = Math.max(colno - 60, 0);\n  if (start < 5) {\n    start = 0;\n  }\n\n  let end = Math.min(start + 140, lineLength);\n  if (end > lineLength - 5) {\n    end = lineLength;\n  }\n  if (end === lineLength) {\n    start = Math.max(end - 140, 0);\n  }\n\n  newLine = newLine.slice(start, end);\n  if (start > 0) {\n    newLine = `'{snip} ${newLine}`;\n  }\n  if (end < lineLength) {\n    newLine += ' {snip}';\n  }\n\n  return newLine;\n}\n\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction safeJoin(input, delimiter) {\n  if (!Array.isArray(input)) {\n    return '';\n  }\n\n  const output = [];\n  // eslint-disable-next-line @typescript-eslint/prefer-for-of\n  for (let i = 0; i < input.length; i++) {\n    const value = input[i];\n    try {\n      output.push(String(value));\n    } catch (e) {\n      output.push('[value cannot be serialized]');\n    }\n  }\n\n  return output.join(delimiter);\n}\n\n/**\n * Checks if the value matches a regex or includes the string\n * @param value The string value to be checked against\n * @param pattern Either a regex or a string that must be contained in value\n */\nfunction isMatchingPattern(value, pattern) {\n  if (!isString(value)) {\n    return false;\n  }\n\n  if (isRegExp(pattern)) {\n    return pattern.test(value);\n  }\n  if (typeof pattern === 'string') {\n    return value.indexOf(pattern) !== -1;\n  }\n  return false;\n}\n\n/**\n * Given a string, escape characters which have meaning in the regex grammar, such that the result is safe to feed to\n * `new RegExp()`.\n *\n * Based on https://github.com/sindresorhus/escape-string-regexp. Vendored to a) reduce the size by skipping the runtime\n * type-checking, and b) ensure it gets down-compiled for old versions of Node (the published package only supports Node\n * 12+).\n *\n * @param regexString The string to escape\n * @returns An version of the string with all special regex characters escaped\n */\nfunction escapeStringForRegex(regexString) {\n  // escape the hyphen separately so we can also replace it with a unicode literal hyphen, to avoid the problems\n  // discussed in https://github.com/sindresorhus/escape-string-regexp/issues/20.\n  return regexString.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d');\n}\n\nexport { escapeStringForRegex, isMatchingPattern, safeJoin, snipLine, truncate };\n//# sourceMappingURL=string.js.map\n","import { logger } from './logger.js';\nimport { getGlobalObject } from './worldwide.js';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject();\n\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsErrorEvent() {\n  try {\n    new ErrorEvent('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsDOMError() {\n  try {\n    // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n    // 1 argument required, but only 0 present.\n    // @ts-ignore It really needs 1 argument, not 0.\n    new DOMError('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsDOMException() {\n  try {\n    new DOMException('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsFetch() {\n  if (!('fetch' in WINDOW)) {\n    return false;\n  }\n\n  try {\n    new Headers();\n    new Request('http://www.example.com');\n    new Response();\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction isNativeFetch(func) {\n  return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\nfunction supportsNativeFetch() {\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  // Fast path to avoid DOM I/O\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  if (isNativeFetch(WINDOW.fetch)) {\n    return true;\n  }\n\n  // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)\n  // so create a \"pure\" iframe to see if that has native fetch\n  let result = false;\n  const doc = WINDOW.document;\n  // eslint-disable-next-line deprecation/deprecation\n  if (doc && typeof (doc.createElement ) === 'function') {\n    try {\n      const sandbox = doc.createElement('iframe');\n      sandbox.hidden = true;\n      doc.head.appendChild(sandbox);\n      if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        result = isNativeFetch(sandbox.contentWindow.fetch);\n      }\n      doc.head.removeChild(sandbox);\n    } catch (err) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsReportingObserver() {\n  return 'ReportingObserver' in WINDOW;\n}\n\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsReferrerPolicy() {\n  // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'\n  // (see https://caniuse.com/#feat=referrer-policy),\n  // it doesn't. And it throws an exception instead of ignoring this parameter...\n  // REF: https://github.com/getsentry/raven-js/issues/1233\n\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  try {\n    new Request('_', {\n      referrerPolicy: 'origin' ,\n    });\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\nfunction supportsHistory() {\n  // NOTE: in Chrome App environment, touching history.pushState, *even inside\n  //       a try/catch block*, will cause Chrome to output an error to console.error\n  // borrowed from: https://github.com/angular/angular.js/pull/13945/files\n  /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const chrome = (WINDOW ).chrome;\n  const isChromePackagedApp = chrome && chrome.app && chrome.app.runtime;\n  /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n  const hasHistoryApi = 'history' in WINDOW && !!WINDOW.history.pushState && !!WINDOW.history.replaceState;\n\n  return !isChromePackagedApp && hasHistoryApi;\n}\n\nexport { isNativeFetch, supportsDOMError, supportsDOMException, supportsErrorEvent, supportsFetch, supportsHistory, supportsNativeFetch, supportsReferrerPolicy, supportsReportingObserver };\n//# sourceMappingURL=supports.js.map\n","import { isThenable } from './is.js';\n\n/* eslint-disable @typescript-eslint/explicit-function-return-type */\n\n/** SyncPromise internal states */\nvar States; (function (States) {\n  /** Pending */\n  const PENDING = 0; States[States[\"PENDING\"] = PENDING] = \"PENDING\";\n  /** Resolved / OK */\n  const RESOLVED = 1; States[States[\"RESOLVED\"] = RESOLVED] = \"RESOLVED\";\n  /** Rejected / Error */\n  const REJECTED = 2; States[States[\"REJECTED\"] = REJECTED] = \"REJECTED\";\n})(States || (States = {}));\n\n// Overloads so we can call resolvedSyncPromise without arguments and generic argument\n\n/**\n * Creates a resolved sync promise.\n *\n * @param value the value to resolve the promise with\n * @returns the resolved sync promise\n */\nfunction resolvedSyncPromise(value) {\n  return new SyncPromise(resolve => {\n    resolve(value);\n  });\n}\n\n/**\n * Creates a rejected sync promise.\n *\n * @param value the value to reject the promise with\n * @returns the rejected sync promise\n */\nfunction rejectedSyncPromise(reason) {\n  return new SyncPromise((_, reject) => {\n    reject(reason);\n  });\n}\n\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nclass SyncPromise {\n   __init() {this._state = States.PENDING;}\n   __init2() {this._handlers = [];}\n\n   constructor(\n    executor,\n  ) {;SyncPromise.prototype.__init.call(this);SyncPromise.prototype.__init2.call(this);SyncPromise.prototype.__init3.call(this);SyncPromise.prototype.__init4.call(this);SyncPromise.prototype.__init5.call(this);SyncPromise.prototype.__init6.call(this);\n    try {\n      executor(this._resolve, this._reject);\n    } catch (e) {\n      this._reject(e);\n    }\n  }\n\n  /** JSDoc */\n   then(\n    onfulfilled,\n    onrejected,\n  ) {\n    return new SyncPromise((resolve, reject) => {\n      this._handlers.push([\n        false,\n        result => {\n          if (!onfulfilled) {\n            // TODO: ¯\\_(ツ)_/¯\n            // TODO: FIXME\n            resolve(result );\n          } else {\n            try {\n              resolve(onfulfilled(result));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n        reason => {\n          if (!onrejected) {\n            reject(reason);\n          } else {\n            try {\n              resolve(onrejected(reason));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n      ]);\n      this._executeHandlers();\n    });\n  }\n\n  /** JSDoc */\n   catch(\n    onrejected,\n  ) {\n    return this.then(val => val, onrejected);\n  }\n\n  /** JSDoc */\n   finally(onfinally) {\n    return new SyncPromise((resolve, reject) => {\n      let val;\n      let isRejected;\n\n      return this.then(\n        value => {\n          isRejected = false;\n          val = value;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n        reason => {\n          isRejected = true;\n          val = reason;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n      ).then(() => {\n        if (isRejected) {\n          reject(val);\n          return;\n        }\n\n        resolve(val );\n      });\n    });\n  }\n\n  /** JSDoc */\n    __init3() {this._resolve = (value) => {\n    this._setResult(States.RESOLVED, value);\n  };}\n\n  /** JSDoc */\n    __init4() {this._reject = (reason) => {\n    this._setResult(States.REJECTED, reason);\n  };}\n\n  /** JSDoc */\n    __init5() {this._setResult = (state, value) => {\n    if (this._state !== States.PENDING) {\n      return;\n    }\n\n    if (isThenable(value)) {\n      void (value ).then(this._resolve, this._reject);\n      return;\n    }\n\n    this._state = state;\n    this._value = value;\n\n    this._executeHandlers();\n  };}\n\n  /** JSDoc */\n    __init6() {this._executeHandlers = () => {\n    if (this._state === States.PENDING) {\n      return;\n    }\n\n    const cachedHandlers = this._handlers.slice();\n    this._handlers = [];\n\n    cachedHandlers.forEach(handler => {\n      if (handler[0]) {\n        return;\n      }\n\n      if (this._state === States.RESOLVED) {\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        handler[1](this._value );\n      }\n\n      if (this._state === States.REJECTED) {\n        handler[2](this._value);\n      }\n\n      handler[0] = true;\n    });\n  };}\n}\n\nexport { SyncPromise, rejectedSyncPromise, resolvedSyncPromise };\n//# sourceMappingURL=syncpromise.js.map\n","import { dynamicRequire, isNodeEnv } from './node.js';\nimport { getGlobalObject } from './worldwide.js';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject();\n\n/**\n * An object that can return the current timestamp in seconds since the UNIX epoch.\n */\n\n/**\n * A TimestampSource implementation for environments that do not support the Performance Web API natively.\n *\n * Note that this TimestampSource does not use a monotonic clock. A call to `nowSeconds` may return a timestamp earlier\n * than a previously returned value. We do not try to emulate a monotonic behavior in order to facilitate debugging. It\n * is more obvious to explain \"why does my span have negative duration\" than \"why my spans have zero duration\".\n */\nconst dateTimestampSource = {\n  nowSeconds: () => Date.now() / 1000,\n};\n\n/**\n * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}\n * for accessing a high-resolution monotonic clock.\n */\n\n/**\n * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not\n * support the API.\n *\n * Wrapping the native API works around differences in behavior from different browsers.\n */\nfunction getBrowserPerformance() {\n  const { performance } = WINDOW;\n  if (!performance || !performance.now) {\n    return undefined;\n  }\n\n  // Replace performance.timeOrigin with our own timeOrigin based on Date.now().\n  //\n  // This is a partial workaround for browsers reporting performance.timeOrigin such that performance.timeOrigin +\n  // performance.now() gives a date arbitrarily in the past.\n  //\n  // Additionally, computing timeOrigin in this way fills the gap for browsers where performance.timeOrigin is\n  // undefined.\n  //\n  // The assumption that performance.timeOrigin + performance.now() ~= Date.now() is flawed, but we depend on it to\n  // interact with data coming out of performance entries.\n  //\n  // Note that despite recommendations against it in the spec, browsers implement the Performance API with a clock that\n  // might stop when the computer is asleep (and perhaps under other circumstances). Such behavior causes\n  // performance.timeOrigin + performance.now() to have an arbitrary skew over Date.now(). In laptop computers, we have\n  // observed skews that can be as long as days, weeks or months.\n  //\n  // See https://github.com/getsentry/sentry-javascript/issues/2590.\n  //\n  // BUG: despite our best intentions, this workaround has its limitations. It mostly addresses timings of pageload\n  // transactions, but ignores the skew built up over time that can aversely affect timestamps of navigation\n  // transactions of long-lived web pages.\n  const timeOrigin = Date.now() - performance.now();\n\n  return {\n    now: () => performance.now(),\n    timeOrigin,\n  };\n}\n\n/**\n * Returns the native Performance API implementation from Node.js. Returns undefined in old Node.js versions that don't\n * implement the API.\n */\nfunction getNodePerformance() {\n  try {\n    const perfHooks = dynamicRequire(module, 'perf_hooks') ;\n    return perfHooks.performance;\n  } catch (_) {\n    return undefined;\n  }\n}\n\n/**\n * The Performance API implementation for the current platform, if available.\n */\nconst platformPerformance = isNodeEnv() ? getNodePerformance() : getBrowserPerformance();\n\nconst timestampSource =\n  platformPerformance === undefined\n    ? dateTimestampSource\n    : {\n        nowSeconds: () => (platformPerformance.timeOrigin + platformPerformance.now()) / 1000,\n      };\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n */\nconst dateTimestampInSeconds = dateTimestampSource.nowSeconds.bind(dateTimestampSource);\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the\n * availability of the Performance API.\n *\n * See `usingPerformanceAPI` to test whether the Performance API is used.\n *\n * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is\n * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The\n * skew can grow to arbitrary amounts like days, weeks or months.\n * See https://github.com/getsentry/sentry-javascript/issues/2590.\n */\nconst timestampInSeconds = timestampSource.nowSeconds.bind(timestampSource);\n\n// Re-exported with an old name for backwards-compatibility.\nconst timestampWithMs = timestampInSeconds;\n\n/**\n * A boolean that is true when timestampInSeconds uses the Performance API to produce monotonic timestamps.\n */\nconst usingPerformanceAPI = platformPerformance !== undefined;\n\n/**\n * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.\n */\nlet _browserPerformanceTimeOriginMode;\n\n/**\n * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the\n * performance API is available.\n */\nconst browserPerformanceTimeOrigin = (() => {\n  // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or\n  // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin\n  // data as reliable if they are within a reasonable threshold of the current time.\n\n  const { performance } = WINDOW;\n  if (!performance || !performance.now) {\n    _browserPerformanceTimeOriginMode = 'none';\n    return undefined;\n  }\n\n  const threshold = 3600 * 1000;\n  const performanceNow = performance.now();\n  const dateNow = Date.now();\n\n  // if timeOrigin isn't available set delta to threshold so it isn't used\n  const timeOriginDelta = performance.timeOrigin\n    ? Math.abs(performance.timeOrigin + performanceNow - dateNow)\n    : threshold;\n  const timeOriginIsReliable = timeOriginDelta < threshold;\n\n  // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin\n  // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.\n  // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always\n  // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the\n  // Date API.\n  // eslint-disable-next-line deprecation/deprecation\n  const navigationStart = performance.timing && performance.timing.navigationStart;\n  const hasNavigationStart = typeof navigationStart === 'number';\n  // if navigationStart isn't available set delta to threshold so it isn't used\n  const navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;\n  const navigationStartIsReliable = navigationStartDelta < threshold;\n\n  if (timeOriginIsReliable || navigationStartIsReliable) {\n    // Use the more reliable time origin\n    if (timeOriginDelta <= navigationStartDelta) {\n      _browserPerformanceTimeOriginMode = 'timeOrigin';\n      return performance.timeOrigin;\n    } else {\n      _browserPerformanceTimeOriginMode = 'navigationStart';\n      return navigationStart;\n    }\n  }\n\n  // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.\n  _browserPerformanceTimeOriginMode = 'dateNow';\n  return dateNow;\n})();\n\nexport { _browserPerformanceTimeOriginMode, browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds, timestampWithMs, usingPerformanceAPI };\n//# sourceMappingURL=time.js.map\n","/** Internal global with common properties and Sentry extensions  */\n\n// The code below for 'isGlobalObj' and 'GLOBAL_OBJ' was copied from core-js before modification\n// https://github.com/zloirock/core-js/blob/1b944df55282cdc99c90db5f49eb0b6eda2cc0a3/packages/core-js/internals/global.js\n// core-js has the following licence:\n//\n// Copyright (c) 2014-2022 Denis Pushkarev\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/** Returns 'obj' if it's the global object, otherwise returns undefined */\nfunction isGlobalObj(obj) {\n  return obj && obj.Math == Math ? obj : undefined;\n}\n\n/** Get's the global object for the current JavaScript runtime */\nconst GLOBAL_OBJ =\n  (typeof globalThis == 'object' && isGlobalObj(globalThis)) ||\n  // eslint-disable-next-line no-restricted-globals\n  (typeof window == 'object' && isGlobalObj(window)) ||\n  (typeof self == 'object' && isGlobalObj(self)) ||\n  (typeof global == 'object' && isGlobalObj(global)) ||\n  (function () {\n    return this;\n  })() ||\n  {};\n\n/**\n * @deprecated Use GLOBAL_OBJ instead or WINDOW from @sentry/browser. This will be removed in v8\n */\nfunction getGlobalObject() {\n  return GLOBAL_OBJ ;\n}\n\n/**\n * Returns a global singleton contained in the global `__SENTRY__` object.\n *\n * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory\n * function and added to the `__SENTRY__` object.\n *\n * @param name name of the global singleton on __SENTRY__\n * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`\n * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `GLOBAL_OBJ`'s return value\n * @returns the singleton\n */\nfunction getGlobalSingleton(name, creator, obj) {\n  const gbl = (obj || GLOBAL_OBJ) ;\n  const __SENTRY__ = (gbl.__SENTRY__ = gbl.__SENTRY__ || {});\n  const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());\n  return singleton;\n}\n\nexport { GLOBAL_OBJ, getGlobalObject, getGlobalSingleton };\n//# sourceMappingURL=worldwide.js.map\n"],"names":["DEFAULT_BREADCRUMBS","Hub","__init","this","_stack","constructor","client","scope","_version","prototype","call","getStackTop","bindClient","isOlderThan","version","setupIntegrations","pushScope","getScope","getStack","push","getClient","popScope","length","pop","withScope","callback","captureException","exception","hint","eventId","_lastEventId","event_id","syntheticException","Error","_withClient","originalException","captureMessage","message","level","captureEvent","event","type","lastEventId","addBreadcrumb","breadcrumb","beforeBreadcrumb","maxBreadcrumbs","getOptions","mergedBreadcrumb","timestamp","finalBreadcrumb","setUser","user","setTags","tags","setExtras","extras","setTag","key","value","setExtra","extra","setContext","name","context","configureScope","run","oldHub","makeMain","getIntegration","integration","_oO","__SENTRY_DEBUG__","id","startTransaction","customSamplingContext","_callExtensionMethod","traceHeaders","captureSession","endSession","_sendSessionUpdate","layer","session","getSession","setSession","startSession","release","environment","userAgent","getUser","currentSession","status","shouldSendDefaultPii","options","Boolean","sendDefaultPii","method","args","sentry","getMainCarrier","__SENTRY__","extensions","apply","hub","undefined","registry","getHubFromCarrier","setHubOnCarrier","getCurrentHub","hasHubOnCarrier","activeDomain","domain","active","registryHubTopStack","_Oo","getHubFromActiveDomain","carrier","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_attachments","_user","_tags","_extra","_contexts","_sdkProcessingMetadata","static","newScope","_level","_span","_session","_transactionName","_fingerprint","_requestSession","addScopeListener","addEventProcessor","_notifyScopeListeners","getRequestSession","setRequestSession","requestSession","setFingerprint","fingerprint","setLevel","setTransactionName","setSpan","span","getSpan","getTransaction","transaction","update","captureContext","updatedScope","Object","keys","contexts","clear","maxCrumbs","slice","clearBreadcrumbs","addAttachment","attachment","getAttachments","clearAttachments","applyToEvent","trace","getTraceContext","transactionName","_applyFingerprint","breadcrumbs","sdkProcessingMetadata","_notifyEventProcessors","getGlobalEventProcessors","setSDKProcessingMetadata","newData","processors","index","resolve","reject","processor","result","log","then","final","forEach","concat","addGlobalEventProcessor","makeSession","startingTime","sid","init","started","duration","errors","ignoreDuration","toJSON","Date","toISOString","did","attrs","ip_address","ipAddress","user_agent","sessionToJSON","updateSession","email","username","closeSession","SDK_VERSION","DEFAULT_IGNORE_ERRORS","InboundFilters","_options","setupOnce","eventProcess","self","clientOptions","internalOptions","allowUrls","denyUrls","ignoreErrors","ignoreInternal","_mergeOptions","values","e","_isSentryError","oO","_getPossibleEventMessages","some","pattern","_isIgnoredError","url","_getEventFilterUrl","_isDeniedUrl","_isAllowedUrl","_shouldDropEvent","frames","stacktrace","i","frame","filename","_getLastValidUrl","__initStatic","originalFunctionToString","FunctionToString","Function","toString","installedIntegrations","getIntegrationsToSetup","defaultIntegrations","userIntegrations","integrations","isDefaultInstance","Array","isArray","finalIntegrations","integrationsByName","currentInstance","existingInstance","filterDuplicates","debugIndex","findIndex","debugInstance","splice","SentryError","logLevel","super","setPrototypeOf","DSN_REGEX","dsn","withPassword","host","path","pass","port","projectId","protocol","publicKey","dsnFromComponents","components","from","str","match","exec","lastPath","split","join","projectMatch","dsnFromString","component","isValidProtocol","isNaN","parseInt","validateDsn","normalize","input","depth","Infinity","maxProperties","visit","err","ERROR","normalizeToSize","object","maxSize","normalized","encodeURI","utf8Length","JSON","stringify","memo","hasWeakSet","WeakSet","inner","obj","has","add","delete","memoBuilder","memoize","unmemoize","includes","is","stringified","_events","g","window","document","String","getPrototypeOf","stringifyValue","startsWith","replace","valueWithToJSON","numAdded","visitable","visitKey","hasOwnProperty","visitValue","createEnvelope","headers","items","addItemToEnvelope","envelope","newItem","forEachEnvelopeItem","envelopeItem","envelopeItemType","encodeUTF8","textEncoder","TextEncoder","encode","serializeEnvelope","envHeaders","parts","append","next","item","itemHeaders","payload","Uint8Array","stringifiedPayload","buffers","totalLength","reduce","acc","buf","merged","offset","buffer","set","concatBuffers","createAttachmentEnvelopeItem","data","content_type","contentType","attachment_type","attachmentType","ITEM_TYPE_TO_DATA_CATEGORY_MAP","sessions","client_report","user_report","envelopeItemTypeToDataCategory","getBaseApiEndpoint","getEnvelopeEndpointWithUrlEncodedAuth","tunnelOrOptions","tunnel","sdkInfo","_metadata","sdk","_getIngestEndpoint","sentry_key","sentry_version","sentry_client","_encodedAuth","getSdkMetadataForEnvelopeHeader","metadata","createEventEnvelope","eventType","packages","enhanceEventWithSdkInfo","envelopeHeaders","dynamicSamplingContext","sent_at","createEventEnvelopeHeaders","ALREADY_SEEN_ERROR","BaseClient","_integrations","__init2","_integrationsInitialized","__init3","_numProcessing","__init4","_outcomes","_dsn","_transport","transport","recordDroppedEvent","bind","transportOptions","_process","eventFromException","_captureEvent","promisedEvent","eventFromMessage","_isEnabled","sendSession","getDsn","getTransport","flush","timeout","_isClientDoneProcessing","clientFinished","transportFlushed","close","enabled","integrationIndex","indexOf","getIntegrationById","integrationId","sendEvent","env","attachments","_sendEnvelope","createSessionEnvelope","reason","category","sendClientReports","_updateSessionFromEvent","crashed","errored","exceptions","ex","mechanism","handled","sessionNonTerminal","Number","ticked","interval","setInterval","clearInterval","_prepareEvent","normalizeDepth","normalizeMaxBreadth","prepared","_applyClientOptions","_applyIntegrationsMetadata","finalScope","evt","_normalizeEvent","maxBreadth","map","b","spans","dist","maxValueLength","request","integrationsArray","_processEvent","finalEvent","sentryError","beforeSend","sampleRate","isTransaction","Math","random","__sentry__","rv","nullErr","_ensureBeforeSendRv","processedEvent","transactionInfo","transaction_info","source","changes","propagations","promise","send","_clearOutcomes","outcomes","quantity","exceptionFromError","stackParser","parseStackFrames","extractMessage","eventFromError","stack","popSize","framesToPop","reactMinifiedRegexp","test","getPopSize","error","eventFromUnknownInput","attachStacktrace","isUnhandledRejection","domException","eventFromString","code","__serialized__","eventFromPlainObject","synthetic","ignoreOnError","shouldIgnoreOnError","ignoreNextOnError","setTimeout","wrap","fn","before","wrapper","__sentry_wrapped__","sentryWrapped","arguments","wrappedArguments","arg","property","getOwnPropertyDescriptor","configurable","defineProperty","get","validSeverityLevels","severityLevelFromString","parseUrl","query","fragment","relative","BREADCRUMB_INTEGRATION_ID","Breadcrumbs","console","dom","fetch","history","xhr","_consoleBreadcrumb","_innerDomBreadcrumb","handlerData","target","keyAttrs","serializeAttribute","global","_domBreadcrumb","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","logger","endTimestamp","__sentry_own_request__","status_code","body","__sentry_xhr__","fetchData","response","to","parsedLoc","parsedFrom","parsedTo","BrowserClient","_flushOutcomes","breadcrumbIntegration","platform","discarded_events","isRealNavigator","sendBeacon","UNKNOWN_FUNCTION","createFrame","func","lineno","colno","function","in_app","chromeRegex","chromeEvalRegex","geckoREgex","geckoEvalRegex","winjsRegex","defaultStackLineParsers","line","subMatch","extractSafariExtensionDetails","defaultStackParser","isSafariExtension","isSafariWebExtension","DEFAULT_EVENT_TARGET","TryCatch","XMLHttpRequest","eventTarget","requestAnimationFrame","_wrapTimeFunction","_wrapRAF","_wrapXHR","eventTargetOption","_wrapEventTarget","original","originalCallback","handler","originalSend","prop","wrapOptions","originalFunction","globalObject","proto","eventName","handleEvent","originalRemoveEventListener","wrappedEventHandler","originalEventHandler","GlobalHandlers","_installFunc","onerror","_installGlobalOnErrorHandler","onunhandledrejection","_installGlobalOnUnhandledRejectionHandler","stackTraceLimit","installFunc","getHubAndOptions","msg","column","ERROR_TYPES_RE","groups","_enhanceEventWithInitialFrame","_eventFromIncompleteOnError","addMechanismAndCapture","detail","ev","ev0","ev0s","ev0sf","LinkedErrors","_key","_limit","limit","parser","linkedErrors","_walkErrorTree","_handler","Dedupe","eventProcessor","currentEvent","previousEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","_isSameMessageEvent","previousException","_getExceptionFromEvent","currentException","_isSameExceptionEvent","_previousEvent","currentFrames","_getFramesFromEvent","previousFrames","frameA","frameB","currentFingerprint","previousFingerprint","HttpContext","referrer","Referer","makePromiseBuffer","remove","task","$","taskProducer","drain","counter","capturedSetTimeout","clearTimeout","updateRateLimits","limits","statusCode","now","updatedRateLimits","rateLimitHeader","retryAfterHeader","trim","retryAfter","categories","headerDelay","delay","all","header","headerDate","parse","parseRetryAfterHeader","createTransport","makeRequest","bufferSize","rateLimits","filteredEnvelopeItems","envelopeItemDataCategory","disabledUntil","isRateLimited","filteredEnvelope","recordEnvelopeLoss","_","cachedFetchImpl","makeFetchTransport","nativeFetch","fetchImpl","createElement","sandbox","hidden","head","appendChild","contentWindow","removeChild","getNativeFetchImplementation","requestOptions","referrerPolicy","keepalive","fetchOptions","makeXHRTransport","onreadystatechange","readyState","getResponseHeader","open","setRequestHeader","autoSessionTracking","supports","clientClass","debug","warn","initialScope","initAndBind","startSessionOnHub","startSessionTracking","errorCallback","activeTransaction","setStatus","toTraceparent","sample","samplingContext","sampled","setMetadata","tracesSampler","parentSampled","tracesSampleRate","rate","isValidSampleRate","op","_startTransaction","transactionContext","initSpanRecorder","_experiments","startIdleTransaction","idleTimeout","finalTimeout","onScope","heartbeatInterval","addExtensionMethods","_addTracingExtensions","packageToIntegrationMapping","mongodb","module","Mongo","mongoose","mysql","Mysql","pg","Postgres","mappedPackages","filter","moduleName","pkg","p","_autoloadDatabaseIntegrations","DEFAULT_IDLE_TIMEOUT","DEFAULT_FINAL_TIMEOUT","DEFAULT_HEARTBEAT_INTERVAL","IdleTransactionSpanRecorder","_pushActivity","_popActivity","transactionSpanId","maxlen","spanId","finish","IdleTransaction","activities","_heartbeatCounter","_finished","_beforeFinishCallbacks","_idleHub","_idleTimeout","_finalTimeout","_heartbeatInterval","_onScope","clearActiveTransaction","_startIdleTimeout","spanRecorder","keepSpan","startTimestamp","registerBeforeFinishCallback","pushActivity","popActivity","_pingHeartbeat","_cancelIdleTimeout","_idleTimeoutID","_beat","heartbeatString","_prevHeartbeatString","TRACEPARENT_REGEXP","RegExp","BAGGAGE_HEADER_NAME","SENTRY_BAGGAGE_KEY_PREFIX","SENTRY_BAGGAGE_KEY_PREFIX_REGEX","dynamicSamplingContextToSentryBaggageHeader","entries","baggageHeader","objectKey","objectValue","currentIndex","baggageEntry","encodeURIComponent","newBaggageHeader","objectToBaggageHeader","dscKey","dscValue","baggageHeaderToObject","keyOrValue","decodeURIComponent","WINDOW","bindReporter","metric","reportAllChanges","prevValue","delta","forceReport","getNavigationEntry","__WEB_VITALS_POLYFILL__","performance","getEntriesByType","timing","navigation","navigationEntry","entryType","startTime","max","navigationStart","getNavigationEntryFromPerformanceTiming","getActivationStart","navEntry","activationStart","initMetric","navigationType","prerendering","rating","floor","observe","opts","PerformanceObserver","supportedEntryTypes","po","list","getEntries","assign","buffered","onHidden","cb","once","onHiddenOrPageHide","visibilityState","removeEventListener","addEventListener","firstHiddenTime","getVisibilityWatcher","timeStamp","reportedMetricIDs","isMeasurementValue","isFinite","_startChild","ctx","startChild","getBrowserPerformanceAPI","_lcpEntry","_clsEntry","_performanceCursor","_measurements","startTrackingWebVitals","mark","onReport","report","sessionValue","sessionEntries","handleEntries","entry","hadRecentInput","firstSessionEntry","lastSessionEntry","takeRecords","onCLS","unit","visibilityWatcher","lastEntry","stopListening","disconnect","capture","onLCP","_trackLCP","handleEntry","processingStart","onFID","timeOrigin","addPerformanceEntries","performanceEntries","responseStartTimestamp","requestStartTimestamp","_addPerformanceNavigationTiming","description","requestStart","responseEnd","responseStart","_addRequest","_addNavigationSpans","measureStartTimestamp","measureEndTimestamp","_addMeasureSpans","firstHidden","shouldRecord","resourceName","location","origin","initiatorType","transferSize","encodedBodySize","decodedBodySize","_addResourceSpans","navigator","connection","effectiveType","rtt","deviceMemory","hardwareConcurrency","_trackNavigator","oldValue","measurementTimestamp","normalizedValue","abs","fidMark","cls","measurementName","setMeasurement","element","size","sources","node","_tagMetricInfo","eventEnd","end","start","_nullishCoalesce","defaultRequestInstrumentationOptions","traceFetch","traceXHR","tracingOrigins","instrumentOutgoingRequests","shouldCreateSpanForRequest","shouldCreateSpan","shouldAttachHeaders","__span","setHttpStatus","sentryBaggageHeader","sentryTraceHeader","Request","Headers","newHeaders","existingBaggageHeader","baggage","newBaggageHeaders","addTracingHeadersToFetchRequest","getDynamicSamplingContext","fetchCallback","__sentry_xhr_span_id__","xhrCallback","DEFAULT_BROWSER_TRACING_OPTIONS","markBackgroundTransactions","routingInstrumentation","customStartTransaction","startTransactionOnPageLoad","startTransactionOnLocationChange","startingUrl","href","pathname","enableLongTask","BrowserTracing","_emitOptionsWarning","_metricOptions","_reportAllChanges","ops","lastAccessLHS","_optionalChain","_2","_3","_4","_getCurrentHub","instrumentRouting","_createRouteTransaction","statusType","beforeNavigate","isPageloadTransaction","sentryTraceMetaTagValue","getMetaContent","baggageMetaTagValue","traceParentData","traceparent","matches","traceId","parentSpanId","extractTraceparentData","baggageObject","curr","baggageHeaderToDynamicSamplingContext","expandedContext","trimEnd","modifiedContext","finalContext","idleTransaction","metaName","metaTag","getAttribute","__SENTRY_TRACING__","SpanRecorder","_maxlen","Span","substring","__init5","__init6","spanContext","childSpan","logMessage","spanMetadata","setData","httpStatus","spanStatus","spanStatusfromHttpCode","isSuccess","sampledString","toContext","updateWithContext","parent_span_id","span_id","trace_id","start_timestamp","Transaction","_frozenDynamicSamplingContext","_hub","_name","_trimEnd","incomingDynamicSamplingContext","newName","setName","newMetadata","finishedSpans","s","prev","current","measurements","public_key","maybeSampleRate","sample_rate","segment","user_segment","hasTracingEnabled","maybeOptions","getActiveTransaction","maybeHub","msToSec","time","htmlTreeAsString","elem","currentElem","MAX_TRAVERSE_HEIGHT","MAX_OUTPUT_LEN","out","height","len","separator","sepLength","nextStr","_htmlElementAsString","parentNode","reverse","el","className","classes","attr","tagName","toLowerCase","keyAttrPairs","keyAttr","keyAttrPair","allowedAttrs","getLocationHref","getDomElement","selector","querySelector","lhs","rhsFn","handlers","instrumented","instrument","originalConsoleMethod","triggerHandlers","instrumentConsole","triggerDOMHandler","globalDOMEventHandler","makeDOMEventHandler","originalAddEventListener","listener","__sentry_instrumentation_handlers__","handlerForType","refCount","instrumentDOM","xhrproto","originalOpen","xhrInfo","toUpperCase","onreadystatechangeHandler","readyStateArgs","instrumentXHR","originalFetch","getFetchMethod","getFetchUrl","instrumentFetch","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","lastHref","instrumentHistory","_oldOnErrorHandler","_oldOnUnhandledRejectionHandler","addInstrumentationHandler","fetchArgs","debounceTimerID","lastCapturedEvent","globalListener","isContentEditable","shouldSkipDOMEvent","previous","shouldShortcircuitPreviousDebounce","objectToString","isError","wat","isInstanceOf","isBuiltin","isErrorEvent","isDOMError","isDOMException","isString","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","isSyntheticEvent","base","_e","CONSOLE_LEVELS","consoleSandbox","originalConsole","wrappedLevels","originalWrappedFunc","__sentry_original__","makeLogger","enable","disable","uuid4","gbl","crypto","msCrypto","randomUUID","getRandomByte","getRandomValues","c","getFirstException","getEventDescription","firstException","addExceptionTypeValue","addExceptionMechanism","newMechanism","currentMechanism","mergedData","checkOrSetAlreadyCaught","__sentry_captured__","arrayify","maybeArray","isNodeEnv","__SENTRY_BROWSER_BUNDLE__","process","dynamicRequire","mod","require","loadModule","cwd","fill","replacementFactory","wrapped","markFunctionWrapped","addNonEnumerableProperty","writable","getOriginalFunction","urlEncode","convertToPlainObject","getOwnProperties","newObj","serializeEventTarget","currentTarget","CustomEvent","extractedProps","extractExceptionKeysForMessage","maxLength","sort","includedKeys","serialized","dropUndefinedKeys","inputValue","_dropUndefinedKeys","Map","memoizationMap","memoVal","returnValue","createStackParser","parsers","sortedParsers","a","skipFirst","cleanedLine","localStack","firstFrameFunction","lastFrameFunction","stripSentryFramesAndReverse","stackParserFromStackParserOptions","defaultFunctionName","getFunctionName","truncate","substr","safeJoin","delimiter","output","isMatchingPattern","supportsFetch","Response","isNativeFetch","supportsNativeFetch","doc","supportsHistory","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","pushState","replaceState","States","resolvedSyncPromise","SyncPromise","rejectedSyncPromise","_state","PENDING","_handlers","executor","_resolve","_reject","onfulfilled","onrejected","_executeHandlers","catch","val","finally","onfinally","isRejected","_setResult","RESOLVED","REJECTED","state","_value","cachedHandlers","dateTimestampSource","nowSeconds","platformPerformance","getNodePerformance","getBrowserPerformance","timestampSource","dateTimestampInSeconds","timestampInSeconds","timestampWithMs","_browserPerformanceTimeOriginMode","browserPerformanceTimeOrigin","threshold","performanceNow","dateNow","timeOriginDelta","timeOriginIsReliable","navigationStartDelta","isGlobalObj","GLOBAL_OBJ","globalThis","getGlobalObject","getGlobalSingleton","creator"],"sourceRoot":""}