{"version":3,"file":"js/88471-c88a14c8d2c388295dcc.js","mappings":"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","sources":["webpack://StravaModern/./node_modules/@sentry/core/esm/envelope.js","webpack://StravaModern/./node_modules/@sentry/core/esm/baseclient.js","webpack://StravaModern/./node_modules/@sentry/browser/esm/client.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/clientreport.js","webpack://StravaModern/./node_modules/@sentry/browser/esm/eventbuilder.js","webpack://StravaModern/./node_modules/@sentry/browser/esm/helpers.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/severity.js","webpack://StravaModern/./node_modules/@sentry/browser/esm/integrations/breadcrumbs.js","webpack://StravaModern/./node_modules/@sentry/browser/esm/integrations/dedupe.js","webpack://StravaModern/./node_modules/@sentry/browser/esm/integrations/globalhandlers.js","webpack://StravaModern/./node_modules/@sentry/browser/esm/integrations/httpcontext.js","webpack://StravaModern/./node_modules/@sentry/browser/esm/integrations/linkederrors.js","webpack://StravaModern/./node_modules/@sentry/browser/esm/integrations/trycatch.js","webpack://StravaModern/./node_modules/@sentry/browser/esm/sdk.js","webpack://StravaModern/./node_modules/@sentry/core/esm/sdk.js","webpack://StravaModern/./node_modules/@sentry/browser/esm/stack-parsers.js","webpack://StravaModern/./node_modules/@sentry/browser/esm/transports/utils.js","webpack://StravaModern/./node_modules/@sentry/browser/esm/transports/fetch.js","webpack://StravaModern/./node_modules/@sentry/browser/esm/transports/xhr.js","webpack://StravaModern/./node_modules/@sentry/core/esm/api.js","webpack://StravaModern/./node_modules/@sentry/core/esm/exports.js","webpack://StravaModern/./node_modules/@sentry/core/esm/hub.js","webpack://StravaModern/./node_modules/@sentry/core/esm/integration.js","webpack://StravaModern/./node_modules/@sentry/core/esm/integrations/functiontostring.js","webpack://StravaModern/./node_modules/@sentry/core/esm/integrations/inboundfilters.js","webpack://StravaModern/./node_modules/@sentry/core/esm/scope.js","webpack://StravaModern/./node_modules/@sentry/core/esm/session.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/promisebuffer.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/ratelimit.js","webpack://StravaModern/./node_modules/@sentry/core/esm/transports/base.js","webpack://StravaModern/./node_modules/@sentry/core/esm/version.js","webpack://StravaModern/./node_modules/@sentry/browser/esm/index.js","webpack://StravaModern/./node_modules/@sentry/react/esm/constants.js","webpack://StravaModern/./node_modules/@sentry/react/esm/profiler.js","webpack://StravaModern/./node_modules/@sentry/react/esm/errorboundary.js","webpack://StravaModern/./node_modules/@sentry/react/esm/redux.js","webpack://StravaModern/./node_modules/@sentry/react/esm/reactrouterv3.js","webpack://StravaModern/./node_modules/@sentry/react/esm/reactrouterv6.js","webpack://StravaModern/./node_modules/@sentry/react/esm/reactrouter.js","webpack://StravaModern/./node_modules/@sentry/react/esm/sdk.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/errors.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/hubextensions.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/idletransaction.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/tracing.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/baggage.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/bindReporter.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/initMetric.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/generateUniqueID.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/observe.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/onHidden.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/browser/web-vitals/lib/getVisibilityWatcher.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/browser/web-vitals/getLCP.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/browser/metrics/utils.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/browser/metrics/index.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/browser/web-vitals/getCLS.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/browser/web-vitals/getFID.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/browser/request.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/browser/browsertracing.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/browser/router.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/buildPolyfills/_optionalChain.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/browser/backgroundtab.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/index.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/span.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/transaction.js","webpack://StravaModern/./node_modules/@sentry/tracing/esm/utils.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/browser.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/buildPolyfills/_nullishCoalesce.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/dsn.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/envelope.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/error.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/instrument.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/is.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/logger.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/misc.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/node.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/env.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/normalize.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/memo.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/object.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/stacktrace.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/string.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/supports.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/syncpromise.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/time.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/url.js","webpack://StravaModern/./node_modules/@sentry/utils/esm/worldwide.js","webpack://StravaModern/./node_modules/resolve-pathname/esm/resolve-pathname.js","webpack://StravaModern/./node_modules/value-equal/esm/value-equal.js","webpack://StravaModern/./node_modules/history/esm/history.js","webpack://StravaModern/./node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js","webpack://StravaModern/./node_modules/object-assign/index.js","webpack://StravaModern/./node_modules/react-is/cjs/react-is.production.min.js","webpack://StravaModern/./node_modules/react-is/index.js","webpack://StravaModern/./node_modules/react-router/node_modules/mini-create-react-context/dist/esm/index.js","webpack://StravaModern/./node_modules/react-router/esm/react-router.js","webpack://StravaModern/./node_modules/react-router/node_modules/isarray/index.js","webpack://StravaModern/./node_modules/react-router/node_modules/path-to-regexp/index.js","webpack://StravaModern/./node_modules/react-router/node_modules/prop-types/factoryWithThrowingShims.js","webpack://StravaModern/./node_modules/react-router/node_modules/prop-types/index.js","webpack://StravaModern/./node_modules/react-router/node_modules/prop-types/lib/ReactPropTypesSecret.js","webpack://StravaModern/./node_modules/react/cjs/react.production.min.js","webpack://StravaModern/./node_modules/react/index.js","webpack://StravaModern/./node_modules/tiny-invariant/dist/tiny-invariant.esm.js","webpack://StravaModern/./node_modules/@babel/runtime/helpers/esm/extends.js","webpack://StravaModern/./node_modules/@babel/runtime/helpers/esm/inheritsLoose.js","webpack://StravaModern/./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","webpack://StravaModern/./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js"],"sourcesContent":["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 { BaseClient, SDK_VERSION, getCurrentHub, getEnvelopeEndpointWithUrlEncodedAuth } from '@sentry/core';\nimport { WINDOW, getEventDescription, logger, createClientReportEnvelope, dsnToString, serializeEnvelope } from '@sentry/utils';\nimport { eventFromException, eventFromMessage } from './eventbuilder.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 { 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 { withScope, captureException } from '@sentry/core';\nimport { getOriginalFunction, addExceptionTypeValue, addExceptionMechanism, markFunctionWrapped, addNonEnumerableProperty } from '@sentry/utils';\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 { 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","import { getCurrentHub } from '@sentry/core';\nimport { addInstrumentationHandler, htmlTreeAsString, severityLevelFromString, safeJoin, parseUrl, WINDOW } from '@sentry/utils';\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  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 { 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 { 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 { addGlobalEventProcessor, getCurrentHub } from '@sentry/core';\nimport { WINDOW } from '@sentry/utils';\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 { 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 { fill, WINDOW, getFunctionName, getOriginalFunction } from '@sentry/utils';\nimport { 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 { Integrations, getIntegrationsToSetup, initAndBind, getReportDialogEndpoint, getCurrentHub } from '@sentry/core';\nimport { WINDOW, stackParserFromStackParserOptions, supportsFetch, logger, resolvedSyncPromise, addInstrumentationHandler } from '@sentry/utils';\nimport { BrowserClient } from './client.js';\nimport { 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 { 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 { isNativeFetch, WINDOW, logger } from '@sentry/utils';\n\nlet cachedFetchImpl;\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\nexport { getNativeFetchImplementation };\n//# sourceMappingURL=utils.js.map\n","import { createTransport } from '@sentry/core';\nimport { 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    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  }\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 { 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 { getCurrentHub } from './hub.js';\n\n// Note: All functions in this file are typed with a return value of `ReturnType<Hub[HUB_FUNCTION]>`,\n// where HUB_FUNCTION is some method on the Hub class.\n//\n// This is done to make sure the top level SDK methods stay in sync with the hub methods.\n// Although every method here has an explicit return type, some of them (that map to void returns) do not\n// contain `return` keywords. This is done to save on bundle size, as `return` is not minifiable.\n\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception An exception-like object.\n * @param captureContext Additional scope data to apply to exception event.\n * @returns The generated eventId.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\nfunction captureException(exception, captureContext) {\n  return getCurrentHub().captureException(exception, { captureContext });\n}\n\n/**\n * Captures a message event and sends it to Sentry.\n *\n * @param message The message to send to Sentry.\n * @param Severity Define the level of the message.\n * @returns The generated eventId.\n */\nfunction captureMessage(\n  message,\n  // eslint-disable-next-line deprecation/deprecation\n  captureContext,\n) {\n  // This is necessary to provide explicit scopes upgrade, without changing the original\n  // arity of the `captureMessage(message, level)` method.\n  const level = typeof captureContext === 'string' ? captureContext : undefined;\n  const context = typeof captureContext !== 'string' ? { captureContext } : undefined;\n  return getCurrentHub().captureMessage(message, level, context);\n}\n\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param event The event to send to Sentry.\n * @returns The generated eventId.\n */\nfunction captureEvent(event, hint) {\n  return getCurrentHub().captureEvent(event, hint);\n}\n\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n */\nfunction configureScope(callback) {\n  getCurrentHub().configureScope(callback);\n}\n\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on\n * user's actions prior to an error or crash.\n *\n * @param breadcrumb The breadcrumb to record.\n */\nfunction addBreadcrumb(breadcrumb) {\n  getCurrentHub().addBreadcrumb(breadcrumb);\n}\n\n/**\n * Sets context data with the given name.\n * @param name of the context\n * @param context Any kind of data. This data will be normalized.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction setContext(name, context) {\n  getCurrentHub().setContext(name, context);\n}\n\n/**\n * Set an object that will be merged sent as extra data with the event.\n * @param extras Extras object to merge into current context.\n */\nfunction setExtras(extras) {\n  getCurrentHub().setExtras(extras);\n}\n\n/**\n * Set key:value that will be sent as extra data with the event.\n * @param key String of extra\n * @param extra Any kind of data. This data will be normalized.\n */\nfunction setExtra(key, extra) {\n  getCurrentHub().setExtra(key, extra);\n}\n\n/**\n * Set an object that will be merged sent as tags data with the event.\n * @param tags Tags context object to merge into current context.\n */\nfunction setTags(tags) {\n  getCurrentHub().setTags(tags);\n}\n\n/**\n * Set key:value that will be sent as tags data with the event.\n *\n * Can also be used to unset a tag, by passing `undefined`.\n *\n * @param key String key of tag\n * @param value Value of tag\n */\nfunction setTag(key, value) {\n  getCurrentHub().setTag(key, value);\n}\n\n/**\n * Updates user context information for future events.\n *\n * @param user User context object to be set in the current context. Pass `null` to unset the user.\n */\nfunction setUser(user) {\n  getCurrentHub().setUser(user);\n}\n\n/**\n * Creates a new scope with and executes the given operation within.\n * The scope is automatically removed once the operation\n * finishes or throws.\n *\n * This is essentially a convenience function for:\n *\n *     pushScope();\n *     callback();\n *     popScope();\n *\n * @param callback that will be enclosed into push/popScope.\n */\nfunction withScope(callback) {\n  getCurrentHub().withScope(callback);\n}\n\n/**\n * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.\n *\n * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a\n * new child span within the transaction or any span, call the respective `.startChild()` method.\n *\n * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.\n *\n * The transaction must be finished with a call to its `.finish()` method, at which point the transaction with all its\n * finished child spans will be sent to Sentry.\n *\n * NOTE: This function should only be used for *manual* instrumentation. Auto-instrumentation should call\n * `startTransaction` directly on the hub.\n *\n * @param context Properties of the new `Transaction`.\n * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent\n * default values). See {@link Options.tracesSampler}.\n *\n * @returns The transaction which was just started\n */\nfunction startTransaction(\n  context,\n  customSamplingContext,\n) {\n  return getCurrentHub().startTransaction({ ...context }, customSamplingContext);\n}\n\nexport { addBreadcrumb, captureEvent, captureException, captureMessage, configureScope, setContext, setExtra, setExtras, setTag, setTags, setUser, startTransaction, withScope };\n//# sourceMappingURL=exports.js.map\n","import { uuid4, dateTimestampInSeconds, consoleSandbox, logger, GLOBAL_OBJ, isNodeEnv, getGlobalSingleton } from '@sentry/utils';\nimport { Scope } from './scope.js';\nimport { closeSession, makeSession, updateSession } from './session.js';\n\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be increased when the global interface\n * changes and new methods are introduced.\n *\n * @hidden\n */\nconst API_VERSION = 4;\n\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nconst DEFAULT_BREADCRUMBS = 100;\n\n/**\n * A layer in the process stack.\n * @hidden\n */\n\n/**\n * @inheritDoc\n */\nclass Hub  {\n  /** Is a {@link Layer}[] containing the client and scope */\n    __init() {this._stack = [{}];}\n\n  /** Contains the last event id of a captured event.  */\n\n  /**\n   * Creates a new instance of the hub, will push one {@link Layer} into the\n   * internal stack on creation.\n   *\n   * @param client bound to the hub.\n   * @param scope bound to the hub.\n   * @param version number, higher number means higher priority.\n   */\n   constructor(client, scope = new Scope(),   _version = API_VERSION) {;this._version = _version;Hub.prototype.__init.call(this);\n    this.getStackTop().scope = scope;\n    if (client) {\n      this.bindClient(client);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   isOlderThan(version) {\n    return this._version < version;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   bindClient(client) {\n    const top = this.getStackTop();\n    top.client = client;\n    if (client && client.setupIntegrations) {\n      client.setupIntegrations();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   pushScope() {\n    // We want to clone the content of prev scope\n    const scope = Scope.clone(this.getScope());\n    this.getStack().push({\n      client: this.getClient(),\n      scope,\n    });\n    return scope;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   popScope() {\n    if (this.getStack().length <= 1) return false;\n    return !!this.getStack().pop();\n  }\n\n  /**\n   * @inheritDoc\n   */\n   withScope(callback) {\n    const scope = this.pushScope();\n    try {\n      callback(scope);\n    } finally {\n      this.popScope();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   getClient() {\n    return this.getStackTop().client ;\n  }\n\n  /** Returns the scope of the top stack. */\n   getScope() {\n    return this.getStackTop().scope;\n  }\n\n  /** Returns the scope stack for domains or the process. */\n   getStack() {\n    return this._stack;\n  }\n\n  /** Returns the topmost scope layer in the order domain > local > process. */\n   getStackTop() {\n    return this._stack[this._stack.length - 1];\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n   captureException(exception, hint) {\n    const eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n    const syntheticException = new Error('Sentry syntheticException');\n    this._withClient((client, scope) => {\n      client.captureException(\n        exception,\n        {\n          originalException: exception,\n          syntheticException,\n          ...hint,\n          event_id: eventId,\n        },\n        scope,\n      );\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureMessage(\n    message,\n    // eslint-disable-next-line deprecation/deprecation\n    level,\n    hint,\n  ) {\n    const eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n    const syntheticException = new Error(message);\n    this._withClient((client, scope) => {\n      client.captureMessage(\n        message,\n        level,\n        {\n          originalException: message,\n          syntheticException,\n          ...hint,\n          event_id: eventId,\n        },\n        scope,\n      );\n    });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureEvent(event, hint) {\n    const eventId = hint && hint.event_id ? hint.event_id : uuid4();\n    if (event.type !== '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 { 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","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 { 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 { 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","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","const SDK_VERSION = '7.16.0';\n\nexport { SDK_VERSION };\n//# sourceMappingURL=version.js.map\n","import './exports.js';\nimport { Integrations } from '@sentry/core';\nexport { FunctionToString, Hub, InboundFilters, SDK_VERSION, Scope, addBreadcrumb, addGlobalEventProcessor, captureEvent, captureException, captureMessage, configureScope, createTransport, getCurrentHub, getHubFromCarrier, makeMain, setContext, setExtra, setExtras, setTag, setTags, setUser, startTransaction, withScope } from '@sentry/core';\nimport { WINDOW } from '@sentry/utils';\nimport * as index from './integrations/index.js';\nexport { BrowserClient } from './client.js';\nexport { makeFetchTransport } from './transports/fetch.js';\nexport { makeXHRTransport } from './transports/xhr.js';\nexport { chromeStackLineParser, defaultStackLineParsers, defaultStackParser, geckoStackLineParser, opera10StackLineParser, opera11StackLineParser, winjsStackLineParser } from './stack-parsers.js';\nexport { close, defaultIntegrations, flush, forceLoad, init, lastEventId, onLoad, showReportDialog, wrap } from './sdk.js';\nexport { GlobalHandlers } from './integrations/globalhandlers.js';\nexport { TryCatch } from './integrations/trycatch.js';\nexport { Breadcrumbs } from './integrations/breadcrumbs.js';\nexport { LinkedErrors } from './integrations/linkederrors.js';\nexport { HttpContext } from './integrations/httpcontext.js';\nexport { Dedupe } from './integrations/dedupe.js';\n\nlet windowIntegrations = {};\n\n// This block is needed to add compatibility with the integrations packages when used with a CDN\nif (WINDOW.Sentry && WINDOW.Sentry.Integrations) {\n  windowIntegrations = WINDOW.Sentry.Integrations;\n}\n\nconst INTEGRATIONS = {\n  ...windowIntegrations,\n  ...Integrations,\n  ...index,\n};\n\nexport { INTEGRATIONS as Integrations };\n//# sourceMappingURL=index.js.map\n","const REACT_RENDER_OP = 'ui.react.render';\n\nconst REACT_UPDATE_OP = 'ui.react.update';\n\nconst REACT_MOUNT_OP = 'ui.react.mount';\n\nexport { REACT_MOUNT_OP, REACT_RENDER_OP, REACT_UPDATE_OP };\n//# sourceMappingURL=constants.js.map\n","import { getCurrentHub } from '@sentry/browser';\nimport { timestampWithMs } from '@sentry/utils';\nimport hoistNonReactStatics from 'hoist-non-react-statics';\nimport * as React from 'react';\nimport { REACT_MOUNT_OP, REACT_UPDATE_OP, REACT_RENDER_OP } from './constants.js';\n\nconst _jsxFileName = \"/home/runner/work/sentry-javascript/sentry-javascript/packages/react/src/profiler.tsx\";/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n\nconst UNKNOWN_COMPONENT = 'unknown';\n\n/**\n * The Profiler component leverages Sentry's Tracing integration to generate\n * spans based on component lifecycles.\n */\nclass Profiler extends React.Component {\n  /**\n   * The span of the mount activity\n   * Made protected for the React Native SDK to access\n   */\n   __init() {this._mountSpan = undefined;}\n  /**\n   * The span that represents the duration of time between shouldComponentUpdate and componentDidUpdate\n   */\n   __init2() {this._updateSpan = undefined;}\n\n  // eslint-disable-next-line @typescript-eslint/member-ordering\n   static __initStatic() {this.defaultProps = {\n    disabled: false,\n    includeRender: true,\n    includeUpdates: true,\n  };}\n\n   constructor(props) {\n    super(props);Profiler.prototype.__init.call(this);Profiler.prototype.__init2.call(this);;\n    const { name, disabled = false } = this.props;\n\n    if (disabled) {\n      return;\n    }\n\n    const activeTransaction = getActiveTransaction();\n    if (activeTransaction) {\n      this._mountSpan = activeTransaction.startChild({\n        description: `<${name}>`,\n        op: REACT_MOUNT_OP,\n      });\n    }\n  }\n\n  // If a component mounted, we can finish the mount activity.\n   componentDidMount() {\n    if (this._mountSpan) {\n      this._mountSpan.finish();\n    }\n  }\n\n   shouldComponentUpdate({ updateProps, includeUpdates = true }) {\n    // Only generate an update span if includeUpdates is true, if there is a valid mountSpan,\n    // and if the updateProps have changed. It is ok to not do a deep equality check here as it is expensive.\n    // We are just trying to give baseline clues for further investigation.\n    if (includeUpdates && this._mountSpan && updateProps !== this.props.updateProps) {\n      // See what props haved changed between the previous props, and the current props. This is\n      // set as data on the span. We just store the prop keys as the values could be potenially very large.\n      const changedProps = Object.keys(updateProps).filter(k => updateProps[k] !== this.props.updateProps[k]);\n      if (changedProps.length > 0) {\n        const now = timestampWithMs();\n        this._updateSpan = this._mountSpan.startChild({\n          data: {\n            changedProps,\n          },\n          description: `<${this.props.name}>`,\n          op: REACT_UPDATE_OP,\n          startTimestamp: now,\n        });\n      }\n    }\n\n    return true;\n  }\n\n   componentDidUpdate() {\n    if (this._updateSpan) {\n      this._updateSpan.finish();\n      this._updateSpan = undefined;\n    }\n  }\n\n  // If a component is unmounted, we can say it is no longer on the screen.\n  // This means we can finish the span representing the component render.\n   componentWillUnmount() {\n    const { name, includeRender = true } = this.props;\n\n    if (this._mountSpan && includeRender) {\n      // If we were able to obtain the spanId of the mount activity, we should set the\n      // next activity as a child to the component mount activity.\n      this._mountSpan.startChild({\n        description: `<${name}>`,\n        endTimestamp: timestampWithMs(),\n        op: REACT_RENDER_OP,\n        startTimestamp: this._mountSpan.endTimestamp,\n      });\n    }\n  }\n\n   render() {\n    return this.props.children;\n  }\n} Profiler.__initStatic();\n\n/**\n * withProfiler is a higher order component that wraps a\n * component in a {@link Profiler} component. It is recommended that\n * the higher order component be used over the regular {@link Profiler} component.\n *\n * @param WrappedComponent component that is wrapped by Profiler\n * @param options the {@link ProfilerProps} you can pass into the Profiler\n */\nfunction withProfiler(\n  WrappedComponent,\n  // We do not want to have `updateProps` given in options, it is instead filled through the HOC.\n  options,\n) {\n  const componentDisplayName =\n    (options && options.name) || WrappedComponent.displayName || WrappedComponent.name || UNKNOWN_COMPONENT;\n\n  const Wrapped = (props) => (\n    React.createElement(Profiler, { ...options, name: componentDisplayName, updateProps: props, __self: this, __source: {fileName: _jsxFileName, lineNumber: 143}}\n      , React.createElement(WrappedComponent, { ...props, __self: this, __source: {fileName: _jsxFileName, lineNumber: 144}} )\n    )\n  );\n\n  Wrapped.displayName = `profiler(${componentDisplayName})`;\n\n  // Copy over static methods from Wrapped component to Profiler HOC\n  // See: https://reactjs.org/docs/higher-order-components.html#static-methods-must-be-copied-over\n  hoistNonReactStatics(Wrapped, WrappedComponent);\n  return Wrapped;\n}\n\n/**\n *\n * `useProfiler` is a React hook that profiles a React component.\n *\n * Requires React 16.8 or above.\n * @param name displayName of component being profiled\n */\nfunction useProfiler(\n  name,\n  options = {\n    disabled: false,\n    hasRenderSpan: true,\n  },\n) {\n  const [mountSpan] = React.useState(() => {\n    if (options && options.disabled) {\n      return undefined;\n    }\n\n    const activeTransaction = getActiveTransaction();\n    if (activeTransaction) {\n      return activeTransaction.startChild({\n        description: `<${name}>`,\n        op: REACT_MOUNT_OP,\n      });\n    }\n\n    return undefined;\n  });\n\n  React.useEffect(() => {\n    if (mountSpan) {\n      mountSpan.finish();\n    }\n\n    return () => {\n      if (mountSpan && options.hasRenderSpan) {\n        mountSpan.startChild({\n          description: `<${name}>`,\n          endTimestamp: timestampWithMs(),\n          op: REACT_RENDER_OP,\n          startTimestamp: mountSpan.endTimestamp,\n        });\n      }\n    };\n    // We only want this to run once.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n}\n\n/** Grabs active transaction off scope */\nfunction getActiveTransaction(hub = getCurrentHub()) {\n  if (hub) {\n    const scope = hub.getScope();\n    if (scope) {\n      return scope.getTransaction() ;\n    }\n  }\n\n  return undefined;\n}\n\nexport { Profiler, UNKNOWN_COMPONENT, getActiveTransaction, useProfiler, withProfiler };\n//# sourceMappingURL=profiler.js.map\n","import { withScope, captureException, showReportDialog } from '@sentry/browser';\nimport { logger } from '@sentry/utils';\nimport hoistNonReactStatics from 'hoist-non-react-statics';\nimport * as React from 'react';\n\nconst _jsxFileName = \"/home/runner/work/sentry-javascript/sentry-javascript/packages/react/src/errorboundary.tsx\";\nfunction isAtLeastReact17(version) {\n  const major = version.match(/^([^.]+)/);\n  return major !== null && parseInt(major[0]) >= 17;\n}\n\nconst UNKNOWN_COMPONENT = 'unknown';\n\nconst INITIAL_STATE = {\n  componentStack: null,\n  error: null,\n  eventId: null,\n};\n\n/**\n * A ErrorBoundary component that logs errors to Sentry. Requires React >= 16.\n * NOTE: If you are a Sentry user, and you are seeing this stack frame, it means the\n * Sentry React SDK ErrorBoundary caught an error invoking your application code. This\n * is expected behavior and NOT indicative of a bug with the Sentry React SDK.\n */\nclass ErrorBoundary extends React.Component {constructor(...args) { super(...args); ErrorBoundary.prototype.__init.call(this);ErrorBoundary.prototype.__init2.call(this); }\n   __init() {this.state = INITIAL_STATE;}\n\n   componentDidCatch(error, { componentStack }) {\n    const { beforeCapture, onError, showDialog, dialogOptions } = this.props;\n\n    withScope(scope => {\n      // If on React version >= 17, create stack trace from componentStack param and links\n      // to to the original error using `error.cause` otherwise relies on error param for stacktrace.\n      // Linking errors requires the `LinkedErrors` integration be enabled.\n      if (isAtLeastReact17(React.version)) {\n        const errorBoundaryError = new Error(error.message);\n        errorBoundaryError.name = `React ErrorBoundary ${errorBoundaryError.name}`;\n        errorBoundaryError.stack = componentStack;\n\n        // Using the `LinkedErrors` integration to link the errors together.\n        error.cause = errorBoundaryError;\n      }\n\n      if (beforeCapture) {\n        beforeCapture(scope, error, componentStack);\n      }\n      const eventId = captureException(error, { contexts: { react: { componentStack } } });\n      if (onError) {\n        onError(error, componentStack, eventId);\n      }\n      if (showDialog) {\n        showReportDialog({ ...dialogOptions, eventId });\n      }\n\n      // componentDidCatch is used over getDerivedStateFromError\n      // so that componentStack is accessible through state.\n      this.setState({ error, componentStack, eventId });\n    });\n  }\n\n   componentDidMount() {\n    const { onMount } = this.props;\n    if (onMount) {\n      onMount();\n    }\n  }\n\n   componentWillUnmount() {\n    const { error, componentStack, eventId } = this.state;\n    const { onUnmount } = this.props;\n    if (onUnmount) {\n      onUnmount(error, componentStack, eventId);\n    }\n  }\n\n   __init2() {this.resetErrorBoundary = () => {\n    const { onReset } = this.props;\n    const { error, componentStack, eventId } = this.state;\n    if (onReset) {\n      onReset(error, componentStack, eventId);\n    }\n    this.setState(INITIAL_STATE);\n  };}\n\n   render() {\n    const { fallback, children } = this.props;\n    const { error, componentStack, eventId } = this.state;\n\n    if (error) {\n      let element = undefined;\n      if (typeof fallback === 'function') {\n        element = fallback({ error, componentStack, resetError: this.resetErrorBoundary, eventId });\n      } else {\n        element = fallback;\n      }\n\n      if (React.isValidElement(element)) {\n        return element;\n      }\n\n      if (fallback) {\n        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('fallback did not produce a valid ReactElement');\n      }\n\n      // Fail gracefully if no fallback provided or is not valid\n      return null;\n    }\n\n    if (typeof children === 'function') {\n      return (children )();\n    }\n    return children;\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction withErrorBoundary(\n  WrappedComponent,\n  errorBoundaryOptions,\n) {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  const componentDisplayName = WrappedComponent.displayName || WrappedComponent.name || UNKNOWN_COMPONENT;\n\n  const Wrapped = (props) => (\n    React.createElement(ErrorBoundary, { ...errorBoundaryOptions, __self: this, __source: {fileName: _jsxFileName, lineNumber: 168}}\n      , React.createElement(WrappedComponent, { ...props, __self: this, __source: {fileName: _jsxFileName, lineNumber: 169}} )\n    )\n  );\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  Wrapped.displayName = `errorBoundary(${componentDisplayName})`;\n\n  // Copy over static methods from Wrapped component to Profiler HOC\n  // See: https://reactjs.org/docs/higher-order-components.html#static-methods-must-be-copied-over\n  hoistNonReactStatics(Wrapped, WrappedComponent);\n  return Wrapped;\n}\n\nexport { ErrorBoundary, UNKNOWN_COMPONENT, isAtLeastReact17, withErrorBoundary };\n//# sourceMappingURL=errorboundary.js.map\n","import { configureScope } from '@sentry/browser';\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nconst ACTION_BREADCRUMB_CATEGORY = 'redux.action';\nconst ACTION_BREADCRUMB_TYPE = 'info';\n\nconst defaultOptions = {\n  actionTransformer: action => action,\n  stateTransformer: state => state || null,\n};\n\n/**\n * Creates an enhancer that would be passed to Redux's createStore to log actions and the latest state to Sentry.\n *\n * @param enhancerOptions Options to pass to the enhancer\n */\nfunction createReduxEnhancer(enhancerOptions) {\n  // Note: We return an any type as to not have type conflicts.\n  const options = {\n    ...defaultOptions,\n    ...enhancerOptions,\n  };\n\n  return (next) =>\n    (reducer, initialState) => {\n      const sentryReducer = (state, action) => {\n        const newState = reducer(state, action);\n\n        configureScope(scope => {\n          /* Action breadcrumbs */\n          const transformedAction = options.actionTransformer(action);\n          if (typeof transformedAction !== 'undefined' && transformedAction !== null) {\n            scope.addBreadcrumb({\n              category: ACTION_BREADCRUMB_CATEGORY,\n              data: transformedAction,\n              type: ACTION_BREADCRUMB_TYPE,\n            });\n          }\n\n          /* Set latest state to scope */\n          const transformedState = options.stateTransformer(newState);\n          if (typeof transformedState !== 'undefined' && transformedState !== null) {\n            scope.setContext('state', { state: { type: 'redux', value: transformedState } });\n          } else {\n            scope.setContext('state', null);\n          }\n\n          /* Allow user to configure scope with latest state */\n          // eslint-disable-next-line @typescript-eslint/unbound-method\n          const { configureScopeWithState } = options;\n          if (typeof configureScopeWithState === 'function') {\n            configureScopeWithState(scope, newState);\n          }\n        });\n\n        return newState;\n      };\n\n      return next(sentryReducer, initialState);\n    };\n}\n\nexport { createReduxEnhancer };\n//# sourceMappingURL=redux.js.map\n","import { WINDOW } from '@sentry/utils';\n\n// Many of the types below had to be mocked out to prevent typescript issues\n// these types are required for correct functionality.\n\n/**\n * Creates routing instrumentation for React Router v3\n * Works for React Router >= 3.2.0 and < 4.0.0\n *\n * @param history object from the `history` library\n * @param routes a list of all routes, should be\n * @param match `Router.match` utility\n */\nfunction reactRouterV3Instrumentation(\n  history,\n  routes,\n  match,\n) {\n  return (\n    startTransaction,\n    startTransactionOnPageLoad = true,\n    startTransactionOnLocationChange = true,\n  ) => {\n    let activeTransaction;\n    let prevName;\n\n    // Have to use window.location because history.location might not be defined.\n    if (startTransactionOnPageLoad && WINDOW && WINDOW.location) {\n      normalizeTransactionName(\n        routes,\n        WINDOW.location ,\n        match,\n        (localName, source = 'url') => {\n          prevName = localName;\n          activeTransaction = startTransaction({\n            name: prevName,\n            op: 'pageload',\n            tags: {\n              'routing.instrumentation': 'react-router-v3',\n            },\n            metadata: {\n              source,\n            },\n          });\n        },\n      );\n    }\n\n    if (startTransactionOnLocationChange && history.listen) {\n      history.listen(location => {\n        if (location.action === 'PUSH' || location.action === 'POP') {\n          if (activeTransaction) {\n            activeTransaction.finish();\n          }\n          const tags = {\n            'routing.instrumentation': 'react-router-v3',\n          };\n          if (prevName) {\n            tags.from = prevName;\n          }\n          normalizeTransactionName(routes, location, match, (localName, source = 'url') => {\n            prevName = localName;\n            activeTransaction = startTransaction({\n              name: prevName,\n              op: 'navigation',\n              tags,\n              metadata: {\n                source,\n              },\n            });\n          });\n        }\n      });\n    }\n  };\n}\n\n/**\n * Normalize transaction names using `Router.match`\n */\nfunction normalizeTransactionName(\n  appRoutes,\n  location,\n  match,\n  callback,\n) {\n  let name = location.pathname;\n  match(\n    {\n      location,\n      routes: appRoutes,\n    },\n    (error, _redirectLocation, renderProps) => {\n      if (error || !renderProps) {\n        return callback(name);\n      }\n\n      const routePath = getRouteStringFromRoutes(renderProps.routes || []);\n      if (routePath.length === 0 || routePath === '/*') {\n        return callback(name);\n      }\n\n      name = routePath;\n      return callback(name, 'route');\n    },\n  );\n}\n\n/**\n * Generate route name from array of routes\n */\nfunction getRouteStringFromRoutes(routes) {\n  if (!Array.isArray(routes) || routes.length === 0) {\n    return '';\n  }\n\n  const routesWithPaths = routes.filter((route) => !!route.path);\n\n  let index = -1;\n  for (let x = routesWithPaths.length - 1; x >= 0; x--) {\n    const route = routesWithPaths[x];\n    if (route.path && route.path.startsWith('/')) {\n      index = x;\n      break;\n    }\n  }\n\n  return routesWithPaths\n    .slice(index)\n    .filter(({ path }) => !!path)\n    .map(({ path }) => path)\n    .join('');\n}\n\nexport { reactRouterV3Instrumentation };\n//# sourceMappingURL=reactrouterv3.js.map\n","import { WINDOW, getNumberOfUrlSegments, logger } from '@sentry/utils';\nimport hoistNonReactStatics from 'hoist-non-react-statics';\nimport React__default from 'react';\n\nconst _jsxFileName = \"/home/runner/work/sentry-javascript/sentry-javascript/packages/react/src/reactrouterv6.tsx\";\n\nlet activeTransaction;\n\nlet _useEffect;\nlet _useLocation;\nlet _useNavigationType;\nlet _createRoutesFromChildren;\nlet _matchRoutes;\nlet _customStartTransaction;\nlet _startTransactionOnLocationChange;\n\nconst SENTRY_TAGS = {\n  'routing.instrumentation': 'react-router-v6',\n};\n\nfunction reactRouterV6Instrumentation(\n  useEffect,\n  useLocation,\n  useNavigationType,\n  createRoutesFromChildren,\n  matchRoutes,\n) {\n  return (\n    customStartTransaction,\n    startTransactionOnPageLoad = true,\n    startTransactionOnLocationChange = true,\n  ) => {\n    const initPathName = WINDOW && WINDOW.location && WINDOW.location.pathname;\n    if (startTransactionOnPageLoad && initPathName) {\n      activeTransaction = customStartTransaction({\n        name: initPathName,\n        op: 'pageload',\n        tags: SENTRY_TAGS,\n        metadata: {\n          source: 'url',\n        },\n      });\n    }\n\n    _useEffect = useEffect;\n    _useLocation = useLocation;\n    _useNavigationType = useNavigationType;\n    _matchRoutes = matchRoutes;\n    _createRoutesFromChildren = createRoutesFromChildren;\n\n    _customStartTransaction = customStartTransaction;\n    _startTransactionOnLocationChange = startTransactionOnLocationChange;\n  };\n}\n\nfunction getNormalizedName(\n  routes,\n  location,\n  matchRoutes,\n) {\n  if (!routes || routes.length === 0 || !matchRoutes) {\n    return [location.pathname, 'url'];\n  }\n\n  const branches = matchRoutes(routes, location);\n\n  let pathBuilder = '';\n  if (branches) {\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (let x = 0; x < branches.length; x++) {\n      const branch = branches[x];\n      const route = branch.route;\n      if (route) {\n        // Early return if index route\n        if (route.index) {\n          return [branch.pathname, 'route'];\n        }\n\n        const path = route.path;\n        if (path) {\n          const newPath = path[0] === '/' || pathBuilder[pathBuilder.length - 1] === '/' ? path : `/${path}`;\n          pathBuilder += newPath;\n          if (branch.pathname === location.pathname) {\n            if (\n              // If the route defined on the element is something like\n              // <Route path=\"/stores/:storeId/products/:productId\" element={<div>Product</div>} />\n              // We should check against the branch.pathname for the number of / seperators\n              getNumberOfUrlSegments(pathBuilder) !== getNumberOfUrlSegments(branch.pathname) &&\n              // We should not count wildcard operators in the url segments calculation\n              pathBuilder.slice(-2) !== '/*'\n            ) {\n              return [newPath, 'route'];\n            }\n            return [pathBuilder, 'route'];\n          }\n        }\n      }\n    }\n  }\n\n  return [location.pathname, 'url'];\n}\n\nfunction updatePageloadTransaction(location, routes) {\n  if (activeTransaction) {\n    activeTransaction.setName(...getNormalizedName(routes, location, _matchRoutes));\n  }\n}\n\nfunction handleNavigation(\n  location,\n  routes,\n  navigationType,\n  isBaseLocation,\n) {\n  if (isBaseLocation) {\n    if (activeTransaction) {\n      activeTransaction.finish();\n    }\n\n    return;\n  }\n\n  if (_startTransactionOnLocationChange && (navigationType === 'PUSH' || navigationType === 'POP')) {\n    if (activeTransaction) {\n      activeTransaction.finish();\n    }\n\n    const [name, source] = getNormalizedName(routes, location, _matchRoutes);\n    activeTransaction = _customStartTransaction({\n      name,\n      op: 'navigation',\n      tags: SENTRY_TAGS,\n      metadata: {\n        source,\n      },\n    });\n  }\n}\n\nfunction withSentryReactRouterV6Routing(Routes) {\n  if (\n    !_useEffect ||\n    !_useLocation ||\n    !_useNavigationType ||\n    !_createRoutesFromChildren ||\n    !_matchRoutes ||\n    !_customStartTransaction\n  ) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(`reactRouterV6Instrumentation was unable to wrap Routes because of one or more missing parameters.\n      useEffect: ${_useEffect}. useLocation: ${_useLocation}. useNavigationType: ${_useNavigationType}.\n      createRoutesFromChildren: ${_createRoutesFromChildren}. matchRoutes: ${_matchRoutes}. customStartTransaction: ${_customStartTransaction}.`);\n\n    return Routes;\n  }\n\n  let isBaseLocation = false;\n  let routes;\n\n  const SentryRoutes = (props) => {\n    const location = _useLocation();\n    const navigationType = _useNavigationType();\n\n    _useEffect(() => {\n      // Performance concern:\n      // This is repeated when <Routes /> is rendered.\n      routes = _createRoutesFromChildren(props.children);\n      isBaseLocation = true;\n\n      updatePageloadTransaction(location, routes);\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [props.children]);\n\n    _useEffect(() => {\n      handleNavigation(location, routes, navigationType, isBaseLocation);\n    }, [props.children, location, navigationType, isBaseLocation]);\n\n    isBaseLocation = false;\n\n    // @ts-ignore Setting more specific React Component typing for `R` generic above\n    // will break advanced type inference done by react router params\n    return React__default.createElement(Routes, { ...props, __self: this, __source: {fileName: _jsxFileName, lineNumber: 227}} );\n  };\n\n  hoistNonReactStatics(SentryRoutes, Routes);\n\n  // @ts-ignore Setting more specific React Component typing for `R` generic above\n  // will break advanced type inference done by react router params\n  return SentryRoutes;\n}\n\nfunction wrapUseRoutes(origUseRoutes) {\n  if (!_useEffect || !_useLocation || !_useNavigationType || !_matchRoutes || !_customStartTransaction) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.warn(\n        'reactRouterV6Instrumentation was unable to wrap `useRoutes` because of one or more missing parameters.',\n      );\n\n    return origUseRoutes;\n  }\n\n  let isBaseLocation = false;\n\n  return (routes, location) => {\n    const SentryRoutes = (props) => {\n      const Routes = origUseRoutes(routes, location);\n\n      const locationArgObject = typeof location === 'string' ? { pathname: location } : location;\n      const locationObject = (locationArgObject ) || _useLocation();\n      const navigationType = _useNavigationType();\n\n      _useEffect(() => {\n        isBaseLocation = true;\n\n        updatePageloadTransaction(locationObject, routes);\n      }, [props]);\n\n      _useEffect(() => {\n        handleNavigation(locationObject, routes, navigationType, isBaseLocation);\n      }, [props, locationObject, navigationType, isBaseLocation]);\n\n      isBaseLocation = false;\n\n      return Routes;\n    };\n\n    return React__default.createElement(SentryRoutes, {__self: this, __source: {fileName: _jsxFileName, lineNumber: 272}} );\n  };\n}\n\nexport { reactRouterV6Instrumentation, withSentryReactRouterV6Routing, wrapUseRoutes };\n//# sourceMappingURL=reactrouterv6.js.map\n","import { WINDOW } from '@sentry/utils';\nimport hoistNonReactStatics from 'hoist-non-react-statics';\nimport * as React from 'react';\n\nconst _jsxFileName = \"/home/runner/work/sentry-javascript/sentry-javascript/packages/react/src/reactrouter.tsx\";\n\n// We need to disable eslint no-explict-any because any is required for the\n// react-router typings.\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\n/* eslint-enable @typescript-eslint/no-explicit-any */\n\nlet activeTransaction;\n\nfunction reactRouterV4Instrumentation(\n  history,\n  routes,\n  matchPath,\n) {\n  return createReactRouterInstrumentation(history, 'react-router-v4', routes, matchPath);\n}\n\nfunction reactRouterV5Instrumentation(\n  history,\n  routes,\n  matchPath,\n) {\n  return createReactRouterInstrumentation(history, 'react-router-v5', routes, matchPath);\n}\n\nfunction createReactRouterInstrumentation(\n  history,\n  name,\n  allRoutes = [],\n  matchPath,\n) {\n  function getInitPathName() {\n    if (history && history.location) {\n      return history.location.pathname;\n    }\n\n    if (WINDOW && WINDOW.location) {\n      return WINDOW.location.pathname;\n    }\n\n    return undefined;\n  }\n\n  /**\n   * Normalizes a transaction name. Returns the new name as well as the\n   * source of the transaction.\n   *\n   * @param pathname The initial pathname we normalize\n   */\n  function normalizeTransactionName(pathname) {\n    if (allRoutes.length === 0 || !matchPath) {\n      return [pathname, 'url'];\n    }\n\n    const branches = matchRoutes(allRoutes, pathname, matchPath);\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (let x = 0; x < branches.length; x++) {\n      if (branches[x].match.isExact) {\n        return [branches[x].match.path, 'route'];\n      }\n    }\n\n    return [pathname, 'url'];\n  }\n\n  const tags = {\n    'routing.instrumentation': name,\n  };\n\n  return (customStartTransaction, startTransactionOnPageLoad = true, startTransactionOnLocationChange = true) => {\n    const initPathName = getInitPathName();\n    if (startTransactionOnPageLoad && initPathName) {\n      const [name, source] = normalizeTransactionName(initPathName);\n      activeTransaction = customStartTransaction({\n        name,\n        op: 'pageload',\n        tags,\n        metadata: {\n          source,\n        },\n      });\n    }\n\n    if (startTransactionOnLocationChange && history.listen) {\n      history.listen((location, action) => {\n        if (action && (action === 'PUSH' || action === 'POP')) {\n          if (activeTransaction) {\n            activeTransaction.finish();\n          }\n\n          const [name, source] = normalizeTransactionName(location.pathname);\n          activeTransaction = customStartTransaction({\n            name,\n            op: 'navigation',\n            tags,\n            metadata: {\n              source,\n            },\n          });\n        }\n      });\n    }\n  };\n}\n\n/**\n * Matches a set of routes to a pathname\n * Based on implementation from\n */\nfunction matchRoutes(\n  routes,\n  pathname,\n  matchPath,\n  branch = [],\n) {\n  routes.some(route => {\n    const match = route.path\n      ? matchPath(pathname, route)\n      : branch.length\n      ? branch[branch.length - 1].match // use parent match\n      : computeRootMatch(pathname); // use default \"root\" match\n\n    if (match) {\n      branch.push({ route, match });\n\n      if (route.routes) {\n        matchRoutes(route.routes, pathname, matchPath, branch);\n      }\n    }\n\n    return !!match;\n  });\n\n  return branch;\n}\n\nfunction computeRootMatch(pathname) {\n  return { path: '/', url: '/', params: {}, isExact: pathname === '/' };\n}\n\n/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */\nfunction withSentryRouting(Route) {\n  const componentDisplayName = (Route ).displayName || (Route ).name;\n\n  const WrappedRoute = (props) => {\n    if (activeTransaction && props && props.computedMatch && props.computedMatch.isExact) {\n      activeTransaction.setName(props.computedMatch.path, 'route');\n    }\n\n    // @ts-ignore Setting more specific React Component typing for `R` generic above\n    // will break advanced type inference done by react router params:\n    // https://github.com/DefinitelyTyped/DefinitelyTyped/blob/13dc4235c069e25fe7ee16e11f529d909f9f3ff8/types/react-router/index.d.ts#L154-L164\n    return React.createElement(Route, { ...props, __self: this, __source: {fileName: _jsxFileName, lineNumber: 174}} );\n  };\n\n  WrappedRoute.displayName = `sentryRoute(${componentDisplayName})`;\n  hoistNonReactStatics(WrappedRoute, Route);\n  // @ts-ignore Setting more specific React Component typing for `R` generic above\n  // will break advanced type inference done by react router params:\n  // https://github.com/DefinitelyTyped/DefinitelyTyped/blob/13dc4235c069e25fe7ee16e11f529d909f9f3ff8/types/react-router/index.d.ts#L154-L164\n  return WrappedRoute;\n}\n/* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access */\n\nexport { reactRouterV4Instrumentation, reactRouterV5Instrumentation, withSentryRouting };\n//# sourceMappingURL=reactrouter.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","const bindReporter = (\n  callback,\n  metric,\n  reportAllChanges,\n) => {\n  let prevValue;\n  return (forceReport) => {\n    if (metric.value >= 0) {\n      if (forceReport || reportAllChanges) {\n        metric.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 (metric.delta || prevValue === undefined) {\n          prevValue = metric.value;\n          callback(metric);\n        }\n      }\n    }\n  };\n};\n\nexport { bindReporter };\n//# sourceMappingURL=bindReporter.js.map\n","import { _nullishCoalesce } from '@sentry/utils/esm/buildPolyfills';\nimport { generateUniqueID } from './generateUniqueID.js';\n\nconst initMetric = (name, value) => {\n  return {\n    name,\n    value: _nullishCoalesce(value, () => ( -1)),\n    delta: 0,\n    entries: [],\n    id: generateUniqueID(),\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 `v2-${Date.now()}-${Math.floor(Math.random() * (9e12 - 1)) + 1e12}`;\n};\n\nexport { generateUniqueID };\n//# sourceMappingURL=generateUniqueID.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 * 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 = (type, callback) => {\n  try {\n    if (PerformanceObserver.supportedEntryTypes.includes(type)) {\n      // More extensive feature detect needed for Firefox due to:\n      // https://github.com/GoogleChrome/web-vitals/issues/142\n      if (type === 'first-input' && !('PerformanceEventTiming' in self)) {\n        return;\n      }\n\n      const po = new PerformanceObserver(l => l.getEntries().map(callback));\n\n      po.observe({ type, buffered: true });\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 '@sentry/utils';\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 '@sentry/utils';\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  return WINDOW.document.visibilityState === 'hidden' ? 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 { 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// https://wicg.github.io/largest-contentful-paint/#sec-largest-contentful-paint-interface\n\nconst reportedMetricIDs = {};\n\nconst getLCP = (onReport, reportAllChanges) => {\n  const visibilityWatcher = getVisibilityWatcher();\n  const metric = initMetric('LCP');\n  let report;\n\n  const entryHandler = (entry) => {\n    // The startTime attribute returns the value of the renderTime if it is not 0,\n    // and the value of the loadTime otherwise.\n    const value = entry.startTime;\n\n    // If the page was hidden prior to paint time of the entry,\n    // ignore it and mark the metric as final, otherwise add the entry.\n    if (value < visibilityWatcher.firstHiddenTime) {\n      metric.value = value;\n      metric.entries.push(entry);\n    }\n\n    if (report) {\n      report();\n    }\n  };\n\n  const po = observe('largest-contentful-paint', entryHandler);\n\n  if (po) {\n    report = bindReporter(onReport, metric, reportAllChanges);\n\n    const stopListening = () => {\n      if (!reportedMetricIDs[metric.id]) {\n        po.takeRecords().map(entryHandler );\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 { getLCP };\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 { WINDOW, browserPerformanceTimeOrigin, logger, htmlTreeAsString } from '@sentry/utils';\nimport { getActiveTransaction, msToSec } from '../../utils.js';\nimport { getCLS } from '../web-vitals/getCLS.js';\nimport { getFID } from '../web-vitals/getFID.js';\nimport { getLCP } 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 = (entry) => {\n    const transaction = getActiveTransaction() ;\n    if (!transaction) {\n      return;\n    }\n    const startTime = msToSec((browserPerformanceTimeOrigin ) + entry.startTime);\n    const duration = msToSec(entry.duration);\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  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  getCLS(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  getLCP(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  }, reportAllChanges);\n}\n\n/** Starts tracking the First Input Delay on the current page. */\nfunction _trackFID() {\n  getFID(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// https://wicg.github.io/layout-instability/#sec-layout-shift\n\nconst getCLS = (onReport, reportAllChanges) => {\n  const metric = initMetric('CLS', 0);\n  let report;\n\n  let sessionValue = 0;\n  let sessionEntries = [];\n\n  const entryHandler = (entry) => {\n    // Only count layout shifts without recent user input.\n    // TODO: Figure out why entry can be undefined\n    if (entry && !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  const po = observe('layout-shift', entryHandler );\n  if (po) {\n    report = bindReporter(onReport, metric, reportAllChanges);\n\n    onHidden(() => {\n      po.takeRecords().map(entryHandler );\n      report(true);\n    });\n  }\n};\n\nexport { getCLS };\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\nconst getFID = (onReport, reportAllChanges) => {\n  const visibilityWatcher = getVisibilityWatcher();\n  const metric = initMetric('FID');\n  let report;\n\n  const entryHandler = (entry) => {\n    // Only report if the page wasn't hidden prior to the first input.\n    if (report && entry.startTime < visibilityWatcher.firstHiddenTime) {\n      metric.value = entry.processingStart - entry.startTime;\n      metric.entries.push(entry);\n      report(true);\n    }\n  };\n\n  const po = observe('first-input', entryHandler );\n  if (po) {\n    report = bindReporter(onReport, metric, reportAllChanges);\n    onHidden(() => {\n      po.takeRecords().map(entryHandler );\n      po.disconnect();\n    }, true);\n  }\n};\n\nexport { getFID };\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  // eslint-disable-next-line @typescript-eslint/unbound-method\n  const { traceFetch, traceXHR, tracingOrigins, shouldCreateSpanForRequest } = {\n    ...defaultRequestInstrumentationOptions,\n    ..._options,\n  };\n\n  // We should cache url -> decision so that we don't have to compute\n  // regexp everytime we create a request.\n  const urlMap = {};\n\n  const defaultShouldCreateSpan = (url) => {\n    if (urlMap[url]) {\n      return urlMap[url];\n    }\n    const origins = tracingOrigins;\n    urlMap[url] =\n      origins.some((origin) => isMatchingPattern(url, origin)) &&\n      !isMatchingPattern(url, 'sentry_key');\n    return urlMap[url];\n  };\n\n  // We want that our users don't have to re-implement shouldCreateSpanForRequest themselves\n  // That's why we filter out already unwanted Spans from tracingOrigins\n  let shouldCreateSpan = defaultShouldCreateSpan;\n  if (typeof shouldCreateSpanForRequest === 'function') {\n    shouldCreateSpan = (url) => {\n      return defaultShouldCreateSpan(url) && shouldCreateSpanForRequest(url);\n    };\n  }\n\n  const spans = {};\n\n  if (traceFetch) {\n    addInstrumentationHandler('fetch', (handlerData) => {\n      fetchCallback(handlerData, shouldCreateSpan, spans);\n    });\n  }\n\n  if (traceXHR) {\n    addInstrumentationHandler('xhr', (handlerData) => {\n      xhrCallback(handlerData, shouldCreateSpan, spans);\n    });\n  }\n}\n\n/**\n * Create and track fetch request spans\n */\nfunction fetchCallback(\n  handlerData,\n  shouldCreateSpan,\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    options.headers = addTracingHeadersToFetchRequest(\n      request,\n      activeTransaction.getDynamicSamplingContext(),\n      span,\n      options,\n    );\n\n    activeTransaction.metadata.propagations += 1;\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  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) {\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, WINDOW, 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';\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 { WINDOW, logger, addInstrumentationHandler } from '@sentry/utils';\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 { WINDOW, logger } from '@sentry/utils';\nimport { getActiveTransaction } from '../utils.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 { GLOBAL_OBJ } from './worldwide.js';\n\n/**\n * TODO: Move me to @sentry/browser when @sentry/utils no longer contains any browser code\n */\nconst WINDOW = GLOBAL_OBJ ;\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 { WINDOW, 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 { 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 { 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","/** 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 { WINDOW } from './browser.js';\nimport { 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';\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 { 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 { 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 { WINDOW } from './browser.js';\nimport { logger } from './logger.js';\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 { WINDOW } from './browser.js';\nimport { dynamicRequire, isNodeEnv } from './node.js';\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","/**\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","/** 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. 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","function isAbsolute(pathname) {\n  return pathname.charAt(0) === '/';\n}\n\n// About 1.5x faster than the two-arg version of Array#splice()\nfunction spliceOne(list, index) {\n  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) {\n    list[i] = list[k];\n  }\n\n  list.pop();\n}\n\n// This implementation is based heavily on node's url.parse\nfunction resolvePathname(to, from) {\n  if (from === undefined) from = '';\n\n  var toParts = (to && to.split('/')) || [];\n  var fromParts = (from && from.split('/')) || [];\n\n  var isToAbs = to && isAbsolute(to);\n  var isFromAbs = from && isAbsolute(from);\n  var mustEndAbs = isToAbs || isFromAbs;\n\n  if (to && isAbsolute(to)) {\n    // to is absolute\n    fromParts = toParts;\n  } else if (toParts.length) {\n    // to is relative, drop the filename\n    fromParts.pop();\n    fromParts = fromParts.concat(toParts);\n  }\n\n  if (!fromParts.length) return '/';\n\n  var hasTrailingSlash;\n  if (fromParts.length) {\n    var last = fromParts[fromParts.length - 1];\n    hasTrailingSlash = last === '.' || last === '..' || last === '';\n  } else {\n    hasTrailingSlash = false;\n  }\n\n  var up = 0;\n  for (var i = fromParts.length; i >= 0; i--) {\n    var part = fromParts[i];\n\n    if (part === '.') {\n      spliceOne(fromParts, i);\n    } else if (part === '..') {\n      spliceOne(fromParts, i);\n      up++;\n    } else if (up) {\n      spliceOne(fromParts, i);\n      up--;\n    }\n  }\n\n  if (!mustEndAbs) for (; up--; up) fromParts.unshift('..');\n\n  if (\n    mustEndAbs &&\n    fromParts[0] !== '' &&\n    (!fromParts[0] || !isAbsolute(fromParts[0]))\n  )\n    fromParts.unshift('');\n\n  var result = fromParts.join('/');\n\n  if (hasTrailingSlash && result.substr(-1) !== '/') result += '/';\n\n  return result;\n}\n\nexport default resolvePathname;\n","function valueOf(obj) {\n  return obj.valueOf ? obj.valueOf() : Object.prototype.valueOf.call(obj);\n}\n\nfunction valueEqual(a, b) {\n  // Test for strict equality first.\n  if (a === b) return true;\n\n  // Otherwise, if either of them == null they are not equal.\n  if (a == null || b == null) return false;\n\n  if (Array.isArray(a)) {\n    return (\n      Array.isArray(b) &&\n      a.length === b.length &&\n      a.every(function(item, index) {\n        return valueEqual(item, b[index]);\n      })\n    );\n  }\n\n  if (typeof a === 'object' || typeof b === 'object') {\n    var aValue = valueOf(a);\n    var bValue = valueOf(b);\n\n    if (aValue !== a || bValue !== b) return valueEqual(aValue, bValue);\n\n    return Object.keys(Object.assign({}, a, b)).every(function(key) {\n      return valueEqual(a[key], b[key]);\n    });\n  }\n\n  return false;\n}\n\nexport default valueEqual;\n","import _extends from '@babel/runtime/helpers/esm/extends';\nimport resolvePathname from 'resolve-pathname';\nimport valueEqual from 'value-equal';\nimport warning from 'tiny-warning';\nimport invariant from 'tiny-invariant';\n\nfunction addLeadingSlash(path) {\n  return path.charAt(0) === '/' ? path : '/' + path;\n}\nfunction stripLeadingSlash(path) {\n  return path.charAt(0) === '/' ? path.substr(1) : path;\n}\nfunction hasBasename(path, prefix) {\n  return path.toLowerCase().indexOf(prefix.toLowerCase()) === 0 && '/?#'.indexOf(path.charAt(prefix.length)) !== -1;\n}\nfunction stripBasename(path, prefix) {\n  return hasBasename(path, prefix) ? path.substr(prefix.length) : path;\n}\nfunction stripTrailingSlash(path) {\n  return path.charAt(path.length - 1) === '/' ? path.slice(0, -1) : path;\n}\nfunction parsePath(path) {\n  var pathname = path || '/';\n  var search = '';\n  var hash = '';\n  var hashIndex = pathname.indexOf('#');\n\n  if (hashIndex !== -1) {\n    hash = pathname.substr(hashIndex);\n    pathname = pathname.substr(0, hashIndex);\n  }\n\n  var searchIndex = pathname.indexOf('?');\n\n  if (searchIndex !== -1) {\n    search = pathname.substr(searchIndex);\n    pathname = pathname.substr(0, searchIndex);\n  }\n\n  return {\n    pathname: pathname,\n    search: search === '?' ? '' : search,\n    hash: hash === '#' ? '' : hash\n  };\n}\nfunction createPath(location) {\n  var pathname = location.pathname,\n      search = location.search,\n      hash = location.hash;\n  var path = pathname || '/';\n  if (search && search !== '?') path += search.charAt(0) === '?' ? search : \"?\" + search;\n  if (hash && hash !== '#') path += hash.charAt(0) === '#' ? hash : \"#\" + hash;\n  return path;\n}\n\nfunction createLocation(path, state, key, currentLocation) {\n  var location;\n\n  if (typeof path === 'string') {\n    // Two-arg form: push(path, state)\n    location = parsePath(path);\n    location.state = state;\n  } else {\n    // One-arg form: push(location)\n    location = _extends({}, path);\n    if (location.pathname === undefined) location.pathname = '';\n\n    if (location.search) {\n      if (location.search.charAt(0) !== '?') location.search = '?' + location.search;\n    } else {\n      location.search = '';\n    }\n\n    if (location.hash) {\n      if (location.hash.charAt(0) !== '#') location.hash = '#' + location.hash;\n    } else {\n      location.hash = '';\n    }\n\n    if (state !== undefined && location.state === undefined) location.state = state;\n  }\n\n  try {\n    location.pathname = decodeURI(location.pathname);\n  } catch (e) {\n    if (e instanceof URIError) {\n      throw new URIError('Pathname \"' + location.pathname + '\" could not be decoded. ' + 'This is likely caused by an invalid percent-encoding.');\n    } else {\n      throw e;\n    }\n  }\n\n  if (key) location.key = key;\n\n  if (currentLocation) {\n    // Resolve incomplete/relative pathname relative to current location.\n    if (!location.pathname) {\n      location.pathname = currentLocation.pathname;\n    } else if (location.pathname.charAt(0) !== '/') {\n      location.pathname = resolvePathname(location.pathname, currentLocation.pathname);\n    }\n  } else {\n    // When there is no prior location and pathname is empty, set it to /\n    if (!location.pathname) {\n      location.pathname = '/';\n    }\n  }\n\n  return location;\n}\nfunction locationsAreEqual(a, b) {\n  return a.pathname === b.pathname && a.search === b.search && a.hash === b.hash && a.key === b.key && valueEqual(a.state, b.state);\n}\n\nfunction createTransitionManager() {\n  var prompt = null;\n\n  function setPrompt(nextPrompt) {\n    process.env.NODE_ENV !== \"production\" ? warning(prompt == null, 'A history supports only one prompt at a time') : void 0;\n    prompt = nextPrompt;\n    return function () {\n      if (prompt === nextPrompt) prompt = null;\n    };\n  }\n\n  function confirmTransitionTo(location, action, getUserConfirmation, callback) {\n    // TODO: If another transition starts while we're still confirming\n    // the previous one, we may end up in a weird state. Figure out the\n    // best way to handle this.\n    if (prompt != null) {\n      var result = typeof prompt === 'function' ? prompt(location, action) : prompt;\n\n      if (typeof result === 'string') {\n        if (typeof getUserConfirmation === 'function') {\n          getUserConfirmation(result, callback);\n        } else {\n          process.env.NODE_ENV !== \"production\" ? warning(false, 'A history needs a getUserConfirmation function in order to use a prompt message') : void 0;\n          callback(true);\n        }\n      } else {\n        // Return false from a transition hook to cancel the transition.\n        callback(result !== false);\n      }\n    } else {\n      callback(true);\n    }\n  }\n\n  var listeners = [];\n\n  function appendListener(fn) {\n    var isActive = true;\n\n    function listener() {\n      if (isActive) fn.apply(void 0, arguments);\n    }\n\n    listeners.push(listener);\n    return function () {\n      isActive = false;\n      listeners = listeners.filter(function (item) {\n        return item !== listener;\n      });\n    };\n  }\n\n  function notifyListeners() {\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    listeners.forEach(function (listener) {\n      return listener.apply(void 0, args);\n    });\n  }\n\n  return {\n    setPrompt: setPrompt,\n    confirmTransitionTo: confirmTransitionTo,\n    appendListener: appendListener,\n    notifyListeners: notifyListeners\n  };\n}\n\nvar canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);\nfunction getConfirmation(message, callback) {\n  callback(window.confirm(message)); // eslint-disable-line no-alert\n}\n/**\n * Returns true if the HTML5 history API is supported. Taken from Modernizr.\n *\n * https://github.com/Modernizr/Modernizr/blob/master/LICENSE\n * https://github.com/Modernizr/Modernizr/blob/master/feature-detects/history.js\n * changed to avoid false negatives for Windows Phones: https://github.com/reactjs/react-router/issues/586\n */\n\nfunction supportsHistory() {\n  var ua = window.navigator.userAgent;\n  if ((ua.indexOf('Android 2.') !== -1 || ua.indexOf('Android 4.0') !== -1) && ua.indexOf('Mobile Safari') !== -1 && ua.indexOf('Chrome') === -1 && ua.indexOf('Windows Phone') === -1) return false;\n  return window.history && 'pushState' in window.history;\n}\n/**\n * Returns true if browser fires popstate on hash change.\n * IE10 and IE11 do not.\n */\n\nfunction supportsPopStateOnHashChange() {\n  return window.navigator.userAgent.indexOf('Trident') === -1;\n}\n/**\n * Returns false if using go(n) with hash history causes a full page reload.\n */\n\nfunction supportsGoWithoutReloadUsingHash() {\n  return window.navigator.userAgent.indexOf('Firefox') === -1;\n}\n/**\n * Returns true if a given popstate event is an extraneous WebKit event.\n * Accounts for the fact that Chrome on iOS fires real popstate events\n * containing undefined state when pressing the back button.\n */\n\nfunction isExtraneousPopstateEvent(event) {\n  return event.state === undefined && navigator.userAgent.indexOf('CriOS') === -1;\n}\n\nvar PopStateEvent = 'popstate';\nvar HashChangeEvent = 'hashchange';\n\nfunction getHistoryState() {\n  try {\n    return window.history.state || {};\n  } catch (e) {\n    // IE 11 sometimes throws when accessing window.history.state\n    // See https://github.com/ReactTraining/history/pull/289\n    return {};\n  }\n}\n/**\n * Creates a history object that uses the HTML5 history API including\n * pushState, replaceState, and the popstate event.\n */\n\n\nfunction createBrowserHistory(props) {\n  if (props === void 0) {\n    props = {};\n  }\n\n  !canUseDOM ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Browser history needs a DOM') : invariant(false) : void 0;\n  var globalHistory = window.history;\n  var canUseHistory = supportsHistory();\n  var needsHashChangeListener = !supportsPopStateOnHashChange();\n  var _props = props,\n      _props$forceRefresh = _props.forceRefresh,\n      forceRefresh = _props$forceRefresh === void 0 ? false : _props$forceRefresh,\n      _props$getUserConfirm = _props.getUserConfirmation,\n      getUserConfirmation = _props$getUserConfirm === void 0 ? getConfirmation : _props$getUserConfirm,\n      _props$keyLength = _props.keyLength,\n      keyLength = _props$keyLength === void 0 ? 6 : _props$keyLength;\n  var basename = props.basename ? stripTrailingSlash(addLeadingSlash(props.basename)) : '';\n\n  function getDOMLocation(historyState) {\n    var _ref = historyState || {},\n        key = _ref.key,\n        state = _ref.state;\n\n    var _window$location = window.location,\n        pathname = _window$location.pathname,\n        search = _window$location.search,\n        hash = _window$location.hash;\n    var path = pathname + search + hash;\n    process.env.NODE_ENV !== \"production\" ? warning(!basename || hasBasename(path, basename), 'You are attempting to use a basename on a page whose URL path does not begin ' + 'with the basename. Expected path \"' + path + '\" to begin with \"' + basename + '\".') : void 0;\n    if (basename) path = stripBasename(path, basename);\n    return createLocation(path, state, key);\n  }\n\n  function createKey() {\n    return Math.random().toString(36).substr(2, keyLength);\n  }\n\n  var transitionManager = createTransitionManager();\n\n  function setState(nextState) {\n    _extends(history, nextState);\n\n    history.length = globalHistory.length;\n    transitionManager.notifyListeners(history.location, history.action);\n  }\n\n  function handlePopState(event) {\n    // Ignore extraneous popstate events in WebKit.\n    if (isExtraneousPopstateEvent(event)) return;\n    handlePop(getDOMLocation(event.state));\n  }\n\n  function handleHashChange() {\n    handlePop(getDOMLocation(getHistoryState()));\n  }\n\n  var forceNextPop = false;\n\n  function handlePop(location) {\n    if (forceNextPop) {\n      forceNextPop = false;\n      setState();\n    } else {\n      var action = 'POP';\n      transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n        if (ok) {\n          setState({\n            action: action,\n            location: location\n          });\n        } else {\n          revertPop(location);\n        }\n      });\n    }\n  }\n\n  function revertPop(fromLocation) {\n    var toLocation = history.location; // TODO: We could probably make this more reliable by\n    // keeping a list of keys we've seen in sessionStorage.\n    // Instead, we just default to 0 for keys we don't know.\n\n    var toIndex = allKeys.indexOf(toLocation.key);\n    if (toIndex === -1) toIndex = 0;\n    var fromIndex = allKeys.indexOf(fromLocation.key);\n    if (fromIndex === -1) fromIndex = 0;\n    var delta = toIndex - fromIndex;\n\n    if (delta) {\n      forceNextPop = true;\n      go(delta);\n    }\n  }\n\n  var initialLocation = getDOMLocation(getHistoryState());\n  var allKeys = [initialLocation.key]; // Public interface\n\n  function createHref(location) {\n    return basename + createPath(location);\n  }\n\n  function push(path, state) {\n    process.env.NODE_ENV !== \"production\" ? warning(!(typeof path === 'object' && path.state !== undefined && state !== undefined), 'You should avoid providing a 2nd state argument to push when the 1st ' + 'argument is a location-like object that already has state; it is ignored') : void 0;\n    var action = 'PUSH';\n    var location = createLocation(path, state, createKey(), history.location);\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (!ok) return;\n      var href = createHref(location);\n      var key = location.key,\n          state = location.state;\n\n      if (canUseHistory) {\n        globalHistory.pushState({\n          key: key,\n          state: state\n        }, null, href);\n\n        if (forceRefresh) {\n          window.location.href = href;\n        } else {\n          var prevIndex = allKeys.indexOf(history.location.key);\n          var nextKeys = allKeys.slice(0, prevIndex + 1);\n          nextKeys.push(location.key);\n          allKeys = nextKeys;\n          setState({\n            action: action,\n            location: location\n          });\n        }\n      } else {\n        process.env.NODE_ENV !== \"production\" ? warning(state === undefined, 'Browser history cannot push state in browsers that do not support HTML5 history') : void 0;\n        window.location.href = href;\n      }\n    });\n  }\n\n  function replace(path, state) {\n    process.env.NODE_ENV !== \"production\" ? warning(!(typeof path === 'object' && path.state !== undefined && state !== undefined), 'You should avoid providing a 2nd state argument to replace when the 1st ' + 'argument is a location-like object that already has state; it is ignored') : void 0;\n    var action = 'REPLACE';\n    var location = createLocation(path, state, createKey(), history.location);\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (!ok) return;\n      var href = createHref(location);\n      var key = location.key,\n          state = location.state;\n\n      if (canUseHistory) {\n        globalHistory.replaceState({\n          key: key,\n          state: state\n        }, null, href);\n\n        if (forceRefresh) {\n          window.location.replace(href);\n        } else {\n          var prevIndex = allKeys.indexOf(history.location.key);\n          if (prevIndex !== -1) allKeys[prevIndex] = location.key;\n          setState({\n            action: action,\n            location: location\n          });\n        }\n      } else {\n        process.env.NODE_ENV !== \"production\" ? warning(state === undefined, 'Browser history cannot replace state in browsers that do not support HTML5 history') : void 0;\n        window.location.replace(href);\n      }\n    });\n  }\n\n  function go(n) {\n    globalHistory.go(n);\n  }\n\n  function goBack() {\n    go(-1);\n  }\n\n  function goForward() {\n    go(1);\n  }\n\n  var listenerCount = 0;\n\n  function checkDOMListeners(delta) {\n    listenerCount += delta;\n\n    if (listenerCount === 1 && delta === 1) {\n      window.addEventListener(PopStateEvent, handlePopState);\n      if (needsHashChangeListener) window.addEventListener(HashChangeEvent, handleHashChange);\n    } else if (listenerCount === 0) {\n      window.removeEventListener(PopStateEvent, handlePopState);\n      if (needsHashChangeListener) window.removeEventListener(HashChangeEvent, handleHashChange);\n    }\n  }\n\n  var isBlocked = false;\n\n  function block(prompt) {\n    if (prompt === void 0) {\n      prompt = false;\n    }\n\n    var unblock = transitionManager.setPrompt(prompt);\n\n    if (!isBlocked) {\n      checkDOMListeners(1);\n      isBlocked = true;\n    }\n\n    return function () {\n      if (isBlocked) {\n        isBlocked = false;\n        checkDOMListeners(-1);\n      }\n\n      return unblock();\n    };\n  }\n\n  function listen(listener) {\n    var unlisten = transitionManager.appendListener(listener);\n    checkDOMListeners(1);\n    return function () {\n      checkDOMListeners(-1);\n      unlisten();\n    };\n  }\n\n  var history = {\n    length: globalHistory.length,\n    action: 'POP',\n    location: initialLocation,\n    createHref: createHref,\n    push: push,\n    replace: replace,\n    go: go,\n    goBack: goBack,\n    goForward: goForward,\n    block: block,\n    listen: listen\n  };\n  return history;\n}\n\nvar HashChangeEvent$1 = 'hashchange';\nvar HashPathCoders = {\n  hashbang: {\n    encodePath: function encodePath(path) {\n      return path.charAt(0) === '!' ? path : '!/' + stripLeadingSlash(path);\n    },\n    decodePath: function decodePath(path) {\n      return path.charAt(0) === '!' ? path.substr(1) : path;\n    }\n  },\n  noslash: {\n    encodePath: stripLeadingSlash,\n    decodePath: addLeadingSlash\n  },\n  slash: {\n    encodePath: addLeadingSlash,\n    decodePath: addLeadingSlash\n  }\n};\n\nfunction stripHash(url) {\n  var hashIndex = url.indexOf('#');\n  return hashIndex === -1 ? url : url.slice(0, hashIndex);\n}\n\nfunction getHashPath() {\n  // We can't use window.location.hash here because it's not\n  // consistent across browsers - Firefox will pre-decode it!\n  var href = window.location.href;\n  var hashIndex = href.indexOf('#');\n  return hashIndex === -1 ? '' : href.substring(hashIndex + 1);\n}\n\nfunction pushHashPath(path) {\n  window.location.hash = path;\n}\n\nfunction replaceHashPath(path) {\n  window.location.replace(stripHash(window.location.href) + '#' + path);\n}\n\nfunction createHashHistory(props) {\n  if (props === void 0) {\n    props = {};\n  }\n\n  !canUseDOM ? process.env.NODE_ENV !== \"production\" ? invariant(false, 'Hash history needs a DOM') : invariant(false) : void 0;\n  var globalHistory = window.history;\n  var canGoWithoutReload = supportsGoWithoutReloadUsingHash();\n  var _props = props,\n      _props$getUserConfirm = _props.getUserConfirmation,\n      getUserConfirmation = _props$getUserConfirm === void 0 ? getConfirmation : _props$getUserConfirm,\n      _props$hashType = _props.hashType,\n      hashType = _props$hashType === void 0 ? 'slash' : _props$hashType;\n  var basename = props.basename ? stripTrailingSlash(addLeadingSlash(props.basename)) : '';\n  var _HashPathCoders$hashT = HashPathCoders[hashType],\n      encodePath = _HashPathCoders$hashT.encodePath,\n      decodePath = _HashPathCoders$hashT.decodePath;\n\n  function getDOMLocation() {\n    var path = decodePath(getHashPath());\n    process.env.NODE_ENV !== \"production\" ? warning(!basename || hasBasename(path, basename), 'You are attempting to use a basename on a page whose URL path does not begin ' + 'with the basename. Expected path \"' + path + '\" to begin with \"' + basename + '\".') : void 0;\n    if (basename) path = stripBasename(path, basename);\n    return createLocation(path);\n  }\n\n  var transitionManager = createTransitionManager();\n\n  function setState(nextState) {\n    _extends(history, nextState);\n\n    history.length = globalHistory.length;\n    transitionManager.notifyListeners(history.location, history.action);\n  }\n\n  var forceNextPop = false;\n  var ignorePath = null;\n\n  function locationsAreEqual$$1(a, b) {\n    return a.pathname === b.pathname && a.search === b.search && a.hash === b.hash;\n  }\n\n  function handleHashChange() {\n    var path = getHashPath();\n    var encodedPath = encodePath(path);\n\n    if (path !== encodedPath) {\n      // Ensure we always have a properly-encoded hash.\n      replaceHashPath(encodedPath);\n    } else {\n      var location = getDOMLocation();\n      var prevLocation = history.location;\n      if (!forceNextPop && locationsAreEqual$$1(prevLocation, location)) return; // A hashchange doesn't always == location change.\n\n      if (ignorePath === createPath(location)) return; // Ignore this change; we already setState in push/replace.\n\n      ignorePath = null;\n      handlePop(location);\n    }\n  }\n\n  function handlePop(location) {\n    if (forceNextPop) {\n      forceNextPop = false;\n      setState();\n    } else {\n      var action = 'POP';\n      transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n        if (ok) {\n          setState({\n            action: action,\n            location: location\n          });\n        } else {\n          revertPop(location);\n        }\n      });\n    }\n  }\n\n  function revertPop(fromLocation) {\n    var toLocation = history.location; // TODO: We could probably make this more reliable by\n    // keeping a list of paths we've seen in sessionStorage.\n    // Instead, we just default to 0 for paths we don't know.\n\n    var toIndex = allPaths.lastIndexOf(createPath(toLocation));\n    if (toIndex === -1) toIndex = 0;\n    var fromIndex = allPaths.lastIndexOf(createPath(fromLocation));\n    if (fromIndex === -1) fromIndex = 0;\n    var delta = toIndex - fromIndex;\n\n    if (delta) {\n      forceNextPop = true;\n      go(delta);\n    }\n  } // Ensure the hash is encoded properly before doing anything else.\n\n\n  var path = getHashPath();\n  var encodedPath = encodePath(path);\n  if (path !== encodedPath) replaceHashPath(encodedPath);\n  var initialLocation = getDOMLocation();\n  var allPaths = [createPath(initialLocation)]; // Public interface\n\n  function createHref(location) {\n    var baseTag = document.querySelector('base');\n    var href = '';\n\n    if (baseTag && baseTag.getAttribute('href')) {\n      href = stripHash(window.location.href);\n    }\n\n    return href + '#' + encodePath(basename + createPath(location));\n  }\n\n  function push(path, state) {\n    process.env.NODE_ENV !== \"production\" ? warning(state === undefined, 'Hash history cannot push state; it is ignored') : void 0;\n    var action = 'PUSH';\n    var location = createLocation(path, undefined, undefined, history.location);\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (!ok) return;\n      var path = createPath(location);\n      var encodedPath = encodePath(basename + path);\n      var hashChanged = getHashPath() !== encodedPath;\n\n      if (hashChanged) {\n        // We cannot tell if a hashchange was caused by a PUSH, so we'd\n        // rather setState here and ignore the hashchange. The caveat here\n        // is that other hash histories in the page will consider it a POP.\n        ignorePath = path;\n        pushHashPath(encodedPath);\n        var prevIndex = allPaths.lastIndexOf(createPath(history.location));\n        var nextPaths = allPaths.slice(0, prevIndex + 1);\n        nextPaths.push(path);\n        allPaths = nextPaths;\n        setState({\n          action: action,\n          location: location\n        });\n      } else {\n        process.env.NODE_ENV !== \"production\" ? warning(false, 'Hash history cannot PUSH the same path; a new entry will not be added to the history stack') : void 0;\n        setState();\n      }\n    });\n  }\n\n  function replace(path, state) {\n    process.env.NODE_ENV !== \"production\" ? warning(state === undefined, 'Hash history cannot replace state; it is ignored') : void 0;\n    var action = 'REPLACE';\n    var location = createLocation(path, undefined, undefined, history.location);\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (!ok) return;\n      var path = createPath(location);\n      var encodedPath = encodePath(basename + path);\n      var hashChanged = getHashPath() !== encodedPath;\n\n      if (hashChanged) {\n        // We cannot tell if a hashchange was caused by a REPLACE, so we'd\n        // rather setState here and ignore the hashchange. The caveat here\n        // is that other hash histories in the page will consider it a POP.\n        ignorePath = path;\n        replaceHashPath(encodedPath);\n      }\n\n      var prevIndex = allPaths.indexOf(createPath(history.location));\n      if (prevIndex !== -1) allPaths[prevIndex] = path;\n      setState({\n        action: action,\n        location: location\n      });\n    });\n  }\n\n  function go(n) {\n    process.env.NODE_ENV !== \"production\" ? warning(canGoWithoutReload, 'Hash history go(n) causes a full page reload in this browser') : void 0;\n    globalHistory.go(n);\n  }\n\n  function goBack() {\n    go(-1);\n  }\n\n  function goForward() {\n    go(1);\n  }\n\n  var listenerCount = 0;\n\n  function checkDOMListeners(delta) {\n    listenerCount += delta;\n\n    if (listenerCount === 1 && delta === 1) {\n      window.addEventListener(HashChangeEvent$1, handleHashChange);\n    } else if (listenerCount === 0) {\n      window.removeEventListener(HashChangeEvent$1, handleHashChange);\n    }\n  }\n\n  var isBlocked = false;\n\n  function block(prompt) {\n    if (prompt === void 0) {\n      prompt = false;\n    }\n\n    var unblock = transitionManager.setPrompt(prompt);\n\n    if (!isBlocked) {\n      checkDOMListeners(1);\n      isBlocked = true;\n    }\n\n    return function () {\n      if (isBlocked) {\n        isBlocked = false;\n        checkDOMListeners(-1);\n      }\n\n      return unblock();\n    };\n  }\n\n  function listen(listener) {\n    var unlisten = transitionManager.appendListener(listener);\n    checkDOMListeners(1);\n    return function () {\n      checkDOMListeners(-1);\n      unlisten();\n    };\n  }\n\n  var history = {\n    length: globalHistory.length,\n    action: 'POP',\n    location: initialLocation,\n    createHref: createHref,\n    push: push,\n    replace: replace,\n    go: go,\n    goBack: goBack,\n    goForward: goForward,\n    block: block,\n    listen: listen\n  };\n  return history;\n}\n\nfunction clamp(n, lowerBound, upperBound) {\n  return Math.min(Math.max(n, lowerBound), upperBound);\n}\n/**\n * Creates a history object that stores locations in memory.\n */\n\n\nfunction createMemoryHistory(props) {\n  if (props === void 0) {\n    props = {};\n  }\n\n  var _props = props,\n      getUserConfirmation = _props.getUserConfirmation,\n      _props$initialEntries = _props.initialEntries,\n      initialEntries = _props$initialEntries === void 0 ? ['/'] : _props$initialEntries,\n      _props$initialIndex = _props.initialIndex,\n      initialIndex = _props$initialIndex === void 0 ? 0 : _props$initialIndex,\n      _props$keyLength = _props.keyLength,\n      keyLength = _props$keyLength === void 0 ? 6 : _props$keyLength;\n  var transitionManager = createTransitionManager();\n\n  function setState(nextState) {\n    _extends(history, nextState);\n\n    history.length = history.entries.length;\n    transitionManager.notifyListeners(history.location, history.action);\n  }\n\n  function createKey() {\n    return Math.random().toString(36).substr(2, keyLength);\n  }\n\n  var index = clamp(initialIndex, 0, initialEntries.length - 1);\n  var entries = initialEntries.map(function (entry) {\n    return typeof entry === 'string' ? createLocation(entry, undefined, createKey()) : createLocation(entry, undefined, entry.key || createKey());\n  }); // Public interface\n\n  var createHref = createPath;\n\n  function push(path, state) {\n    process.env.NODE_ENV !== \"production\" ? warning(!(typeof path === 'object' && path.state !== undefined && state !== undefined), 'You should avoid providing a 2nd state argument to push when the 1st ' + 'argument is a location-like object that already has state; it is ignored') : void 0;\n    var action = 'PUSH';\n    var location = createLocation(path, state, createKey(), history.location);\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (!ok) return;\n      var prevIndex = history.index;\n      var nextIndex = prevIndex + 1;\n      var nextEntries = history.entries.slice(0);\n\n      if (nextEntries.length > nextIndex) {\n        nextEntries.splice(nextIndex, nextEntries.length - nextIndex, location);\n      } else {\n        nextEntries.push(location);\n      }\n\n      setState({\n        action: action,\n        location: location,\n        index: nextIndex,\n        entries: nextEntries\n      });\n    });\n  }\n\n  function replace(path, state) {\n    process.env.NODE_ENV !== \"production\" ? warning(!(typeof path === 'object' && path.state !== undefined && state !== undefined), 'You should avoid providing a 2nd state argument to replace when the 1st ' + 'argument is a location-like object that already has state; it is ignored') : void 0;\n    var action = 'REPLACE';\n    var location = createLocation(path, state, createKey(), history.location);\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (!ok) return;\n      history.entries[history.index] = location;\n      setState({\n        action: action,\n        location: location\n      });\n    });\n  }\n\n  function go(n) {\n    var nextIndex = clamp(history.index + n, 0, history.entries.length - 1);\n    var action = 'POP';\n    var location = history.entries[nextIndex];\n    transitionManager.confirmTransitionTo(location, action, getUserConfirmation, function (ok) {\n      if (ok) {\n        setState({\n          action: action,\n          location: location,\n          index: nextIndex\n        });\n      } else {\n        // Mimic the behavior of DOM histories by\n        // causing a render after a cancelled POP.\n        setState();\n      }\n    });\n  }\n\n  function goBack() {\n    go(-1);\n  }\n\n  function goForward() {\n    go(1);\n  }\n\n  function canGo(n) {\n    var nextIndex = history.index + n;\n    return nextIndex >= 0 && nextIndex < history.entries.length;\n  }\n\n  function block(prompt) {\n    if (prompt === void 0) {\n      prompt = false;\n    }\n\n    return transitionManager.setPrompt(prompt);\n  }\n\n  function listen(listener) {\n    return transitionManager.appendListener(listener);\n  }\n\n  var history = {\n    length: entries.length,\n    action: 'POP',\n    location: entries[index],\n    index: index,\n    entries: entries,\n    createHref: createHref,\n    push: push,\n    replace: replace,\n    go: go,\n    goBack: goBack,\n    goForward: goForward,\n    canGo: canGo,\n    block: block,\n    listen: listen\n  };\n  return history;\n}\n\nexport { createBrowserHistory, createHashHistory, createMemoryHistory, createLocation, locationsAreEqual, parsePath, createPath };\n","'use strict';\n\nvar reactIs = require('react-is');\n\n/**\n * Copyright 2015, Yahoo! Inc.\n * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.\n */\nvar REACT_STATICS = {\n  childContextTypes: true,\n  contextType: true,\n  contextTypes: true,\n  defaultProps: true,\n  displayName: true,\n  getDefaultProps: true,\n  getDerivedStateFromError: true,\n  getDerivedStateFromProps: true,\n  mixins: true,\n  propTypes: true,\n  type: true\n};\nvar KNOWN_STATICS = {\n  name: true,\n  length: true,\n  prototype: true,\n  caller: true,\n  callee: true,\n  arguments: true,\n  arity: true\n};\nvar FORWARD_REF_STATICS = {\n  '$$typeof': true,\n  render: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true\n};\nvar MEMO_STATICS = {\n  '$$typeof': true,\n  compare: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true,\n  type: true\n};\nvar TYPE_STATICS = {};\nTYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;\nTYPE_STATICS[reactIs.Memo] = MEMO_STATICS;\n\nfunction getStatics(component) {\n  // React v16.11 and below\n  if (reactIs.isMemo(component)) {\n    return MEMO_STATICS;\n  } // React v16.12 and above\n\n\n  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;\n}\n\nvar defineProperty = Object.defineProperty;\nvar getOwnPropertyNames = Object.getOwnPropertyNames;\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar getPrototypeOf = Object.getPrototypeOf;\nvar objectPrototype = Object.prototype;\nfunction hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {\n  if (typeof sourceComponent !== 'string') {\n    // don't hoist over string (html) components\n    if (objectPrototype) {\n      var inheritedComponent = getPrototypeOf(sourceComponent);\n\n      if (inheritedComponent && inheritedComponent !== objectPrototype) {\n        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);\n      }\n    }\n\n    var keys = getOwnPropertyNames(sourceComponent);\n\n    if (getOwnPropertySymbols) {\n      keys = keys.concat(getOwnPropertySymbols(sourceComponent));\n    }\n\n    var targetStatics = getStatics(targetComponent);\n    var sourceStatics = getStatics(sourceComponent);\n\n    for (var i = 0; i < keys.length; ++i) {\n      var key = keys[i];\n\n      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {\n        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);\n\n        try {\n          // Avoid failures from read-only properties\n          defineProperty(targetComponent, key, descriptor);\n        } catch (e) {}\n      }\n    }\n  }\n\n  return targetComponent;\n}\n\nmodule.exports = hoistNonReactStatics;\n","/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n","/** @license React v16.13.1\n * react-is.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';var b=\"function\"===typeof Symbol&&Symbol.for,c=b?Symbol.for(\"react.element\"):60103,d=b?Symbol.for(\"react.portal\"):60106,e=b?Symbol.for(\"react.fragment\"):60107,f=b?Symbol.for(\"react.strict_mode\"):60108,g=b?Symbol.for(\"react.profiler\"):60114,h=b?Symbol.for(\"react.provider\"):60109,k=b?Symbol.for(\"react.context\"):60110,l=b?Symbol.for(\"react.async_mode\"):60111,m=b?Symbol.for(\"react.concurrent_mode\"):60111,n=b?Symbol.for(\"react.forward_ref\"):60112,p=b?Symbol.for(\"react.suspense\"):60113,q=b?\nSymbol.for(\"react.suspense_list\"):60120,r=b?Symbol.for(\"react.memo\"):60115,t=b?Symbol.for(\"react.lazy\"):60116,v=b?Symbol.for(\"react.block\"):60121,w=b?Symbol.for(\"react.fundamental\"):60117,x=b?Symbol.for(\"react.responder\"):60118,y=b?Symbol.for(\"react.scope\"):60119;\nfunction z(a){if(\"object\"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}exports.AsyncMode=l;exports.ConcurrentMode=m;exports.ContextConsumer=k;exports.ContextProvider=h;exports.Element=c;exports.ForwardRef=n;exports.Fragment=e;exports.Lazy=t;exports.Memo=r;exports.Portal=d;\nexports.Profiler=g;exports.StrictMode=f;exports.Suspense=p;exports.isAsyncMode=function(a){return A(a)||z(a)===l};exports.isConcurrentMode=A;exports.isContextConsumer=function(a){return z(a)===k};exports.isContextProvider=function(a){return z(a)===h};exports.isElement=function(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===c};exports.isForwardRef=function(a){return z(a)===n};exports.isFragment=function(a){return z(a)===e};exports.isLazy=function(a){return z(a)===t};\nexports.isMemo=function(a){return z(a)===r};exports.isPortal=function(a){return z(a)===d};exports.isProfiler=function(a){return z(a)===g};exports.isStrictMode=function(a){return z(a)===f};exports.isSuspense=function(a){return z(a)===p};\nexports.isValidElementType=function(a){return\"string\"===typeof a||\"function\"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||\"object\"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};exports.typeOf=z;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.min.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}\n","import React, { Component } from 'react';\nimport _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport PropTypes from 'prop-types';\nimport warning from 'tiny-warning';\n\nvar MAX_SIGNED_31_BIT_INT = 1073741823;\nvar commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : {};\n\nfunction getUniqueId() {\n  var key = '__global_unique_id__';\n  return commonjsGlobal[key] = (commonjsGlobal[key] || 0) + 1;\n}\n\nfunction objectIs(x, y) {\n  if (x === y) {\n    return x !== 0 || 1 / x === 1 / y;\n  } else {\n    return x !== x && y !== y;\n  }\n}\n\nfunction createEventEmitter(value) {\n  var handlers = [];\n  return {\n    on: function on(handler) {\n      handlers.push(handler);\n    },\n    off: function off(handler) {\n      handlers = handlers.filter(function (h) {\n        return h !== handler;\n      });\n    },\n    get: function get() {\n      return value;\n    },\n    set: function set(newValue, changedBits) {\n      value = newValue;\n      handlers.forEach(function (handler) {\n        return handler(value, changedBits);\n      });\n    }\n  };\n}\n\nfunction onlyChild(children) {\n  return Array.isArray(children) ? children[0] : children;\n}\n\nfunction createReactContext(defaultValue, calculateChangedBits) {\n  var _Provider$childContex, _Consumer$contextType;\n\n  var contextProp = '__create-react-context-' + getUniqueId() + '__';\n\n  var Provider = /*#__PURE__*/function (_Component) {\n    _inheritsLoose(Provider, _Component);\n\n    function Provider() {\n      var _this;\n\n      _this = _Component.apply(this, arguments) || this;\n      _this.emitter = createEventEmitter(_this.props.value);\n      return _this;\n    }\n\n    var _proto = Provider.prototype;\n\n    _proto.getChildContext = function getChildContext() {\n      var _ref;\n\n      return _ref = {}, _ref[contextProp] = this.emitter, _ref;\n    };\n\n    _proto.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {\n      if (this.props.value !== nextProps.value) {\n        var oldValue = this.props.value;\n        var newValue = nextProps.value;\n        var changedBits;\n\n        if (objectIs(oldValue, newValue)) {\n          changedBits = 0;\n        } else {\n          changedBits = typeof calculateChangedBits === 'function' ? calculateChangedBits(oldValue, newValue) : MAX_SIGNED_31_BIT_INT;\n\n          if (process.env.NODE_ENV !== 'production') {\n            warning((changedBits & MAX_SIGNED_31_BIT_INT) === changedBits, 'calculateChangedBits: Expected the return value to be a ' + '31-bit integer. Instead received: ' + changedBits);\n          }\n\n          changedBits |= 0;\n\n          if (changedBits !== 0) {\n            this.emitter.set(nextProps.value, changedBits);\n          }\n        }\n      }\n    };\n\n    _proto.render = function render() {\n      return this.props.children;\n    };\n\n    return Provider;\n  }(Component);\n\n  Provider.childContextTypes = (_Provider$childContex = {}, _Provider$childContex[contextProp] = PropTypes.object.isRequired, _Provider$childContex);\n\n  var Consumer = /*#__PURE__*/function (_Component2) {\n    _inheritsLoose(Consumer, _Component2);\n\n    function Consumer() {\n      var _this2;\n\n      _this2 = _Component2.apply(this, arguments) || this;\n      _this2.state = {\n        value: _this2.getValue()\n      };\n\n      _this2.onUpdate = function (newValue, changedBits) {\n        var observedBits = _this2.observedBits | 0;\n\n        if ((observedBits & changedBits) !== 0) {\n          _this2.setState({\n            value: _this2.getValue()\n          });\n        }\n      };\n\n      return _this2;\n    }\n\n    var _proto2 = Consumer.prototype;\n\n    _proto2.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {\n      var observedBits = nextProps.observedBits;\n      this.observedBits = observedBits === undefined || observedBits === null ? MAX_SIGNED_31_BIT_INT : observedBits;\n    };\n\n    _proto2.componentDidMount = function componentDidMount() {\n      if (this.context[contextProp]) {\n        this.context[contextProp].on(this.onUpdate);\n      }\n\n      var observedBits = this.props.observedBits;\n      this.observedBits = observedBits === undefined || observedBits === null ? MAX_SIGNED_31_BIT_INT : observedBits;\n    };\n\n    _proto2.componentWillUnmount = function componentWillUnmount() {\n      if (this.context[contextProp]) {\n        this.context[contextProp].off(this.onUpdate);\n      }\n    };\n\n    _proto2.getValue = function getValue() {\n      if (this.context[contextProp]) {\n        return this.context[contextProp].get();\n      } else {\n        return defaultValue;\n      }\n    };\n\n    _proto2.render = function render() {\n      return onlyChild(this.props.children)(this.state.value);\n    };\n\n    return Consumer;\n  }(Component);\n\n  Consumer.contextTypes = (_Consumer$contextType = {}, _Consumer$contextType[contextProp] = PropTypes.object, _Consumer$contextType);\n  return {\n    Provider: Provider,\n    Consumer: Consumer\n  };\n}\n\nvar index = React.createContext || createReactContext;\n\nexport default index;\n","import _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport React from 'react';\nimport PropTypes from 'prop-types';\nimport { createMemoryHistory, createLocation, locationsAreEqual, createPath } from 'history';\nimport warning from 'tiny-warning';\nimport createContext from 'mini-create-react-context';\nimport invariant from 'tiny-invariant';\nimport _extends from '@babel/runtime/helpers/esm/extends';\nimport pathToRegexp from 'path-to-regexp';\nimport { isValidElementType } from 'react-is';\nimport _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';\nimport hoistStatics from 'hoist-non-react-statics';\n\n// TODO: Replace with React.createContext once we can assume React 16+\n\nvar createNamedContext = function createNamedContext(name) {\n  var context = createContext();\n  context.displayName = name;\n  return context;\n};\n\nvar historyContext = /*#__PURE__*/createNamedContext(\"Router-History\");\n\nvar context = /*#__PURE__*/createNamedContext(\"Router\");\n\n/**\n * The public API for putting history on context.\n */\n\nvar Router = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(Router, _React$Component);\n\n  Router.computeRootMatch = function computeRootMatch(pathname) {\n    return {\n      path: \"/\",\n      url: \"/\",\n      params: {},\n      isExact: pathname === \"/\"\n    };\n  };\n\n  function Router(props) {\n    var _this;\n\n    _this = _React$Component.call(this, props) || this;\n    _this.state = {\n      location: props.history.location\n    }; // This is a bit of a hack. We have to start listening for location\n    // changes here in the constructor in case there are any <Redirect>s\n    // on the initial render. If there are, they will replace/push when\n    // they mount and since cDM fires in children before parents, we may\n    // get a new location before the <Router> is mounted.\n\n    _this._isMounted = false;\n    _this._pendingLocation = null;\n\n    if (!props.staticContext) {\n      _this.unlisten = props.history.listen(function (location) {\n        _this._pendingLocation = location;\n      });\n    }\n\n    return _this;\n  }\n\n  var _proto = Router.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    var _this2 = this;\n\n    this._isMounted = true;\n\n    if (this.unlisten) {\n      // Any pre-mount location changes have been captured at\n      // this point, so unregister the listener.\n      this.unlisten();\n    }\n\n    if (!this.props.staticContext) {\n      this.unlisten = this.props.history.listen(function (location) {\n        if (_this2._isMounted) {\n          _this2.setState({\n            location: location\n          });\n        }\n      });\n    }\n\n    if (this._pendingLocation) {\n      this.setState({\n        location: this._pendingLocation\n      });\n    }\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    if (this.unlisten) {\n      this.unlisten();\n      this._isMounted = false;\n      this._pendingLocation = null;\n    }\n  };\n\n  _proto.render = function render() {\n    return /*#__PURE__*/React.createElement(context.Provider, {\n      value: {\n        history: this.props.history,\n        location: this.state.location,\n        match: Router.computeRootMatch(this.state.location.pathname),\n        staticContext: this.props.staticContext\n      }\n    }, /*#__PURE__*/React.createElement(historyContext.Provider, {\n      children: this.props.children || null,\n      value: this.props.history\n    }));\n  };\n\n  return Router;\n}(React.Component);\n\nif (process.env.NODE_ENV !== \"production\") {\n  Router.propTypes = {\n    children: PropTypes.node,\n    history: PropTypes.object.isRequired,\n    staticContext: PropTypes.object\n  };\n\n  Router.prototype.componentDidUpdate = function (prevProps) {\n    process.env.NODE_ENV !== \"production\" ? warning(prevProps.history === this.props.history, \"You cannot change <Router history>\") : void 0;\n  };\n}\n\n/**\n * The public API for a <Router> that stores location in memory.\n */\n\nvar MemoryRouter = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(MemoryRouter, _React$Component);\n\n  function MemoryRouter() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n    _this.history = createMemoryHistory(_this.props);\n    return _this;\n  }\n\n  var _proto = MemoryRouter.prototype;\n\n  _proto.render = function render() {\n    return /*#__PURE__*/React.createElement(Router, {\n      history: this.history,\n      children: this.props.children\n    });\n  };\n\n  return MemoryRouter;\n}(React.Component);\n\nif (process.env.NODE_ENV !== \"production\") {\n  MemoryRouter.propTypes = {\n    initialEntries: PropTypes.array,\n    initialIndex: PropTypes.number,\n    getUserConfirmation: PropTypes.func,\n    keyLength: PropTypes.number,\n    children: PropTypes.node\n  };\n\n  MemoryRouter.prototype.componentDidMount = function () {\n    process.env.NODE_ENV !== \"production\" ? warning(!this.props.history, \"<MemoryRouter> ignores the history prop. To use a custom history, \" + \"use `import { Router }` instead of `import { MemoryRouter as Router }`.\") : void 0;\n  };\n}\n\nvar Lifecycle = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(Lifecycle, _React$Component);\n\n  function Lifecycle() {\n    return _React$Component.apply(this, arguments) || this;\n  }\n\n  var _proto = Lifecycle.prototype;\n\n  _proto.componentDidMount = function componentDidMount() {\n    if (this.props.onMount) this.props.onMount.call(this, this);\n  };\n\n  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {\n    if (this.props.onUpdate) this.props.onUpdate.call(this, this, prevProps);\n  };\n\n  _proto.componentWillUnmount = function componentWillUnmount() {\n    if (this.props.onUnmount) this.props.onUnmount.call(this, this);\n  };\n\n  _proto.render = function render() {\n    return null;\n  };\n\n  return Lifecycle;\n}(React.Component);\n\n/**\n * The public API for prompting the user before navigating away from a screen.\n */\n\nfunction Prompt(_ref) {\n  var message = _ref.message,\n      _ref$when = _ref.when,\n      when = _ref$when === void 0 ? true : _ref$when;\n  return /*#__PURE__*/React.createElement(context.Consumer, null, function (context) {\n    !context ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You should not use <Prompt> outside a <Router>\") : invariant(false) : void 0;\n    if (!when || context.staticContext) return null;\n    var method = context.history.block;\n    return /*#__PURE__*/React.createElement(Lifecycle, {\n      onMount: function onMount(self) {\n        self.release = method(message);\n      },\n      onUpdate: function onUpdate(self, prevProps) {\n        if (prevProps.message !== message) {\n          self.release();\n          self.release = method(message);\n        }\n      },\n      onUnmount: function onUnmount(self) {\n        self.release();\n      },\n      message: message\n    });\n  });\n}\n\nif (process.env.NODE_ENV !== \"production\") {\n  var messageType = PropTypes.oneOfType([PropTypes.func, PropTypes.string]);\n  Prompt.propTypes = {\n    when: PropTypes.bool,\n    message: messageType.isRequired\n  };\n}\n\nvar cache = {};\nvar cacheLimit = 10000;\nvar cacheCount = 0;\n\nfunction compilePath(path) {\n  if (cache[path]) return cache[path];\n  var generator = pathToRegexp.compile(path);\n\n  if (cacheCount < cacheLimit) {\n    cache[path] = generator;\n    cacheCount++;\n  }\n\n  return generator;\n}\n/**\n * Public API for generating a URL pathname from a path and parameters.\n */\n\n\nfunction generatePath(path, params) {\n  if (path === void 0) {\n    path = \"/\";\n  }\n\n  if (params === void 0) {\n    params = {};\n  }\n\n  return path === \"/\" ? path : compilePath(path)(params, {\n    pretty: true\n  });\n}\n\n/**\n * The public API for navigating programmatically with a component.\n */\n\nfunction Redirect(_ref) {\n  var computedMatch = _ref.computedMatch,\n      to = _ref.to,\n      _ref$push = _ref.push,\n      push = _ref$push === void 0 ? false : _ref$push;\n  return /*#__PURE__*/React.createElement(context.Consumer, null, function (context) {\n    !context ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You should not use <Redirect> outside a <Router>\") : invariant(false) : void 0;\n    var history = context.history,\n        staticContext = context.staticContext;\n    var method = push ? history.push : history.replace;\n    var location = createLocation(computedMatch ? typeof to === \"string\" ? generatePath(to, computedMatch.params) : _extends({}, to, {\n      pathname: generatePath(to.pathname, computedMatch.params)\n    }) : to); // When rendering in a static context,\n    // set the new location immediately.\n\n    if (staticContext) {\n      method(location);\n      return null;\n    }\n\n    return /*#__PURE__*/React.createElement(Lifecycle, {\n      onMount: function onMount() {\n        method(location);\n      },\n      onUpdate: function onUpdate(self, prevProps) {\n        var prevLocation = createLocation(prevProps.to);\n\n        if (!locationsAreEqual(prevLocation, _extends({}, location, {\n          key: prevLocation.key\n        }))) {\n          method(location);\n        }\n      },\n      to: to\n    });\n  });\n}\n\nif (process.env.NODE_ENV !== \"production\") {\n  Redirect.propTypes = {\n    push: PropTypes.bool,\n    from: PropTypes.string,\n    to: PropTypes.oneOfType([PropTypes.string, PropTypes.object]).isRequired\n  };\n}\n\nvar cache$1 = {};\nvar cacheLimit$1 = 10000;\nvar cacheCount$1 = 0;\n\nfunction compilePath$1(path, options) {\n  var cacheKey = \"\" + options.end + options.strict + options.sensitive;\n  var pathCache = cache$1[cacheKey] || (cache$1[cacheKey] = {});\n  if (pathCache[path]) return pathCache[path];\n  var keys = [];\n  var regexp = pathToRegexp(path, keys, options);\n  var result = {\n    regexp: regexp,\n    keys: keys\n  };\n\n  if (cacheCount$1 < cacheLimit$1) {\n    pathCache[path] = result;\n    cacheCount$1++;\n  }\n\n  return result;\n}\n/**\n * Public API for matching a URL pathname to a path.\n */\n\n\nfunction matchPath(pathname, options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  if (typeof options === \"string\" || Array.isArray(options)) {\n    options = {\n      path: options\n    };\n  }\n\n  var _options = options,\n      path = _options.path,\n      _options$exact = _options.exact,\n      exact = _options$exact === void 0 ? false : _options$exact,\n      _options$strict = _options.strict,\n      strict = _options$strict === void 0 ? false : _options$strict,\n      _options$sensitive = _options.sensitive,\n      sensitive = _options$sensitive === void 0 ? false : _options$sensitive;\n  var paths = [].concat(path);\n  return paths.reduce(function (matched, path) {\n    if (!path && path !== \"\") return null;\n    if (matched) return matched;\n\n    var _compilePath = compilePath$1(path, {\n      end: exact,\n      strict: strict,\n      sensitive: sensitive\n    }),\n        regexp = _compilePath.regexp,\n        keys = _compilePath.keys;\n\n    var match = regexp.exec(pathname);\n    if (!match) return null;\n    var url = match[0],\n        values = match.slice(1);\n    var isExact = pathname === url;\n    if (exact && !isExact) return null;\n    return {\n      path: path,\n      // the path used to match\n      url: path === \"/\" && url === \"\" ? \"/\" : url,\n      // the matched portion of the URL\n      isExact: isExact,\n      // whether or not we matched exactly\n      params: keys.reduce(function (memo, key, index) {\n        memo[key.name] = values[index];\n        return memo;\n      }, {})\n    };\n  }, null);\n}\n\nfunction isEmptyChildren(children) {\n  return React.Children.count(children) === 0;\n}\n\nfunction evalChildrenDev(children, props, path) {\n  var value = children(props);\n  process.env.NODE_ENV !== \"production\" ? warning(value !== undefined, \"You returned `undefined` from the `children` function of \" + (\"<Route\" + (path ? \" path=\\\"\" + path + \"\\\"\" : \"\") + \">, but you \") + \"should have returned a React element or `null`\") : void 0;\n  return value || null;\n}\n/**\n * The public API for matching a single path and rendering.\n */\n\n\nvar Route = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(Route, _React$Component);\n\n  function Route() {\n    return _React$Component.apply(this, arguments) || this;\n  }\n\n  var _proto = Route.prototype;\n\n  _proto.render = function render() {\n    var _this = this;\n\n    return /*#__PURE__*/React.createElement(context.Consumer, null, function (context$1) {\n      !context$1 ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You should not use <Route> outside a <Router>\") : invariant(false) : void 0;\n      var location = _this.props.location || context$1.location;\n      var match = _this.props.computedMatch ? _this.props.computedMatch // <Switch> already computed the match for us\n      : _this.props.path ? matchPath(location.pathname, _this.props) : context$1.match;\n\n      var props = _extends({}, context$1, {\n        location: location,\n        match: match\n      });\n\n      var _this$props = _this.props,\n          children = _this$props.children,\n          component = _this$props.component,\n          render = _this$props.render; // Preact uses an empty array as children by\n      // default, so use null if that's the case.\n\n      if (Array.isArray(children) && isEmptyChildren(children)) {\n        children = null;\n      }\n\n      return /*#__PURE__*/React.createElement(context.Provider, {\n        value: props\n      }, props.match ? children ? typeof children === \"function\" ? process.env.NODE_ENV !== \"production\" ? evalChildrenDev(children, props, _this.props.path) : children(props) : children : component ? /*#__PURE__*/React.createElement(component, props) : render ? render(props) : null : typeof children === \"function\" ? process.env.NODE_ENV !== \"production\" ? evalChildrenDev(children, props, _this.props.path) : children(props) : null);\n    });\n  };\n\n  return Route;\n}(React.Component);\n\nif (process.env.NODE_ENV !== \"production\") {\n  Route.propTypes = {\n    children: PropTypes.oneOfType([PropTypes.func, PropTypes.node]),\n    component: function component(props, propName) {\n      if (props[propName] && !isValidElementType(props[propName])) {\n        return new Error(\"Invalid prop 'component' supplied to 'Route': the prop is not a valid React component\");\n      }\n    },\n    exact: PropTypes.bool,\n    location: PropTypes.object,\n    path: PropTypes.oneOfType([PropTypes.string, PropTypes.arrayOf(PropTypes.string)]),\n    render: PropTypes.func,\n    sensitive: PropTypes.bool,\n    strict: PropTypes.bool\n  };\n\n  Route.prototype.componentDidMount = function () {\n    process.env.NODE_ENV !== \"production\" ? warning(!(this.props.children && !isEmptyChildren(this.props.children) && this.props.component), \"You should not use <Route component> and <Route children> in the same route; <Route component> will be ignored\") : void 0;\n    process.env.NODE_ENV !== \"production\" ? warning(!(this.props.children && !isEmptyChildren(this.props.children) && this.props.render), \"You should not use <Route render> and <Route children> in the same route; <Route render> will be ignored\") : void 0;\n    process.env.NODE_ENV !== \"production\" ? warning(!(this.props.component && this.props.render), \"You should not use <Route component> and <Route render> in the same route; <Route render> will be ignored\") : void 0;\n  };\n\n  Route.prototype.componentDidUpdate = function (prevProps) {\n    process.env.NODE_ENV !== \"production\" ? warning(!(this.props.location && !prevProps.location), '<Route> elements should not change from uncontrolled to controlled (or vice versa). You initially used no \"location\" prop and then provided one on a subsequent render.') : void 0;\n    process.env.NODE_ENV !== \"production\" ? warning(!(!this.props.location && prevProps.location), '<Route> elements should not change from controlled to uncontrolled (or vice versa). You provided a \"location\" prop initially but omitted it on a subsequent render.') : void 0;\n  };\n}\n\nfunction addLeadingSlash(path) {\n  return path.charAt(0) === \"/\" ? path : \"/\" + path;\n}\n\nfunction addBasename(basename, location) {\n  if (!basename) return location;\n  return _extends({}, location, {\n    pathname: addLeadingSlash(basename) + location.pathname\n  });\n}\n\nfunction stripBasename(basename, location) {\n  if (!basename) return location;\n  var base = addLeadingSlash(basename);\n  if (location.pathname.indexOf(base) !== 0) return location;\n  return _extends({}, location, {\n    pathname: location.pathname.substr(base.length)\n  });\n}\n\nfunction createURL(location) {\n  return typeof location === \"string\" ? location : createPath(location);\n}\n\nfunction staticHandler(methodName) {\n  return function () {\n     process.env.NODE_ENV !== \"production\" ? invariant(false, \"You cannot %s with <StaticRouter>\", methodName) : invariant(false) ;\n  };\n}\n\nfunction noop() {}\n/**\n * The public top-level API for a \"static\" <Router>, so-called because it\n * can't actually change the current location. Instead, it just records\n * location changes in a context object. Useful mainly in testing and\n * server-rendering scenarios.\n */\n\n\nvar StaticRouter = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(StaticRouter, _React$Component);\n\n  function StaticRouter() {\n    var _this;\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;\n\n    _this.handlePush = function (location) {\n      return _this.navigateTo(location, \"PUSH\");\n    };\n\n    _this.handleReplace = function (location) {\n      return _this.navigateTo(location, \"REPLACE\");\n    };\n\n    _this.handleListen = function () {\n      return noop;\n    };\n\n    _this.handleBlock = function () {\n      return noop;\n    };\n\n    return _this;\n  }\n\n  var _proto = StaticRouter.prototype;\n\n  _proto.navigateTo = function navigateTo(location, action) {\n    var _this$props = this.props,\n        _this$props$basename = _this$props.basename,\n        basename = _this$props$basename === void 0 ? \"\" : _this$props$basename,\n        _this$props$context = _this$props.context,\n        context = _this$props$context === void 0 ? {} : _this$props$context;\n    context.action = action;\n    context.location = addBasename(basename, createLocation(location));\n    context.url = createURL(context.location);\n  };\n\n  _proto.render = function render() {\n    var _this$props2 = this.props,\n        _this$props2$basename = _this$props2.basename,\n        basename = _this$props2$basename === void 0 ? \"\" : _this$props2$basename,\n        _this$props2$context = _this$props2.context,\n        context = _this$props2$context === void 0 ? {} : _this$props2$context,\n        _this$props2$location = _this$props2.location,\n        location = _this$props2$location === void 0 ? \"/\" : _this$props2$location,\n        rest = _objectWithoutPropertiesLoose(_this$props2, [\"basename\", \"context\", \"location\"]);\n\n    var history = {\n      createHref: function createHref(path) {\n        return addLeadingSlash(basename + createURL(path));\n      },\n      action: \"POP\",\n      location: stripBasename(basename, createLocation(location)),\n      push: this.handlePush,\n      replace: this.handleReplace,\n      go: staticHandler(\"go\"),\n      goBack: staticHandler(\"goBack\"),\n      goForward: staticHandler(\"goForward\"),\n      listen: this.handleListen,\n      block: this.handleBlock\n    };\n    return /*#__PURE__*/React.createElement(Router, _extends({}, rest, {\n      history: history,\n      staticContext: context\n    }));\n  };\n\n  return StaticRouter;\n}(React.Component);\n\nif (process.env.NODE_ENV !== \"production\") {\n  StaticRouter.propTypes = {\n    basename: PropTypes.string,\n    context: PropTypes.object,\n    location: PropTypes.oneOfType([PropTypes.string, PropTypes.object])\n  };\n\n  StaticRouter.prototype.componentDidMount = function () {\n    process.env.NODE_ENV !== \"production\" ? warning(!this.props.history, \"<StaticRouter> ignores the history prop. To use a custom history, \" + \"use `import { Router }` instead of `import { StaticRouter as Router }`.\") : void 0;\n  };\n}\n\n/**\n * The public API for rendering the first <Route> that matches.\n */\n\nvar Switch = /*#__PURE__*/function (_React$Component) {\n  _inheritsLoose(Switch, _React$Component);\n\n  function Switch() {\n    return _React$Component.apply(this, arguments) || this;\n  }\n\n  var _proto = Switch.prototype;\n\n  _proto.render = function render() {\n    var _this = this;\n\n    return /*#__PURE__*/React.createElement(context.Consumer, null, function (context) {\n      !context ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You should not use <Switch> outside a <Router>\") : invariant(false) : void 0;\n      var location = _this.props.location || context.location;\n      var element, match; // We use React.Children.forEach instead of React.Children.toArray().find()\n      // here because toArray adds keys to all child elements and we do not want\n      // to trigger an unmount/remount for two <Route>s that render the same\n      // component at different URLs.\n\n      React.Children.forEach(_this.props.children, function (child) {\n        if (match == null && /*#__PURE__*/React.isValidElement(child)) {\n          element = child;\n          var path = child.props.path || child.props.from;\n          match = path ? matchPath(location.pathname, _extends({}, child.props, {\n            path: path\n          })) : context.match;\n        }\n      });\n      return match ? /*#__PURE__*/React.cloneElement(element, {\n        location: location,\n        computedMatch: match\n      }) : null;\n    });\n  };\n\n  return Switch;\n}(React.Component);\n\nif (process.env.NODE_ENV !== \"production\") {\n  Switch.propTypes = {\n    children: PropTypes.node,\n    location: PropTypes.object\n  };\n\n  Switch.prototype.componentDidUpdate = function (prevProps) {\n    process.env.NODE_ENV !== \"production\" ? warning(!(this.props.location && !prevProps.location), '<Switch> elements should not change from uncontrolled to controlled (or vice versa). You initially used no \"location\" prop and then provided one on a subsequent render.') : void 0;\n    process.env.NODE_ENV !== \"production\" ? warning(!(!this.props.location && prevProps.location), '<Switch> elements should not change from controlled to uncontrolled (or vice versa). You provided a \"location\" prop initially but omitted it on a subsequent render.') : void 0;\n  };\n}\n\n/**\n * A public higher-order component to access the imperative API\n */\n\nfunction withRouter(Component) {\n  var displayName = \"withRouter(\" + (Component.displayName || Component.name) + \")\";\n\n  var C = function C(props) {\n    var wrappedComponentRef = props.wrappedComponentRef,\n        remainingProps = _objectWithoutPropertiesLoose(props, [\"wrappedComponentRef\"]);\n\n    return /*#__PURE__*/React.createElement(context.Consumer, null, function (context) {\n      !context ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You should not use <\" + displayName + \" /> outside a <Router>\") : invariant(false) : void 0;\n      return /*#__PURE__*/React.createElement(Component, _extends({}, remainingProps, context, {\n        ref: wrappedComponentRef\n      }));\n    });\n  };\n\n  C.displayName = displayName;\n  C.WrappedComponent = Component;\n\n  if (process.env.NODE_ENV !== \"production\") {\n    C.propTypes = {\n      wrappedComponentRef: PropTypes.oneOfType([PropTypes.string, PropTypes.func, PropTypes.object])\n    };\n  }\n\n  return hoistStatics(C, Component);\n}\n\nvar useContext = React.useContext;\nfunction useHistory() {\n  if (process.env.NODE_ENV !== \"production\") {\n    !(typeof useContext === \"function\") ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You must use React >= 16.8 in order to use useHistory()\") : invariant(false) : void 0;\n  }\n\n  return useContext(historyContext);\n}\nfunction useLocation() {\n  if (process.env.NODE_ENV !== \"production\") {\n    !(typeof useContext === \"function\") ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You must use React >= 16.8 in order to use useLocation()\") : invariant(false) : void 0;\n  }\n\n  return useContext(context).location;\n}\nfunction useParams() {\n  if (process.env.NODE_ENV !== \"production\") {\n    !(typeof useContext === \"function\") ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You must use React >= 16.8 in order to use useParams()\") : invariant(false) : void 0;\n  }\n\n  var match = useContext(context).match;\n  return match ? match.params : {};\n}\nfunction useRouteMatch(path) {\n  if (process.env.NODE_ENV !== \"production\") {\n    !(typeof useContext === \"function\") ? process.env.NODE_ENV !== \"production\" ? invariant(false, \"You must use React >= 16.8 in order to use useRouteMatch()\") : invariant(false) : void 0;\n  }\n\n  var location = useLocation();\n  var match = useContext(context).match;\n  return path ? matchPath(location.pathname, path) : match;\n}\n\nif (process.env.NODE_ENV !== \"production\") {\n  if (typeof window !== \"undefined\") {\n    var global = window;\n    var key = \"__react_router_build__\";\n    var buildNames = {\n      cjs: \"CommonJS\",\n      esm: \"ES modules\",\n      umd: \"UMD\"\n    };\n\n    if (global[key] && global[key] !== \"esm\") {\n      var initialBuildName = buildNames[global[key]];\n      var secondaryBuildName = buildNames[\"esm\"]; // TODO: Add link to article that explains in detail how to avoid\n      // loading 2 different builds.\n\n      throw new Error(\"You are loading the \" + secondaryBuildName + \" build of React Router \" + (\"on a page that is already running the \" + initialBuildName + \" \") + \"build, so things won't work right.\");\n    }\n\n    global[key] = \"esm\";\n  }\n}\n\nexport { MemoryRouter, Prompt, Redirect, Route, Router, StaticRouter, Switch, historyContext as __HistoryContext, context as __RouterContext, generatePath, matchPath, useHistory, useLocation, useParams, useRouteMatch, withRouter };\n//# sourceMappingURL=react-router.js.map\n","module.exports = Array.isArray || function (arr) {\n  return Object.prototype.toString.call(arr) == '[object Array]';\n};\n","var isarray = require('isarray')\n\n/**\n * Expose `pathToRegexp`.\n */\nmodule.exports = pathToRegexp\nmodule.exports.parse = parse\nmodule.exports.compile = compile\nmodule.exports.tokensToFunction = tokensToFunction\nmodule.exports.tokensToRegExp = tokensToRegExp\n\n/**\n * The main path matching regexp utility.\n *\n * @type {RegExp}\n */\nvar PATH_REGEXP = new RegExp([\n  // Match escaped characters that would otherwise appear in future matches.\n  // This allows the user to escape special characters that won't transform.\n  '(\\\\\\\\.)',\n  // Match Express-style parameters and un-named parameters with a prefix\n  // and optional suffixes. Matches appear as:\n  //\n  // \"/:test(\\\\d+)?\" => [\"/\", \"test\", \"\\d+\", undefined, \"?\", undefined]\n  // \"/route(\\\\d+)\"  => [undefined, undefined, undefined, \"\\d+\", undefined, undefined]\n  // \"/*\"            => [\"/\", undefined, undefined, undefined, undefined, \"*\"]\n  '([\\\\/.])?(?:(?:\\\\:(\\\\w+)(?:\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))?|\\\\(((?:\\\\\\\\.|[^\\\\\\\\()])+)\\\\))([+*?])?|(\\\\*))'\n].join('|'), 'g')\n\n/**\n * Parse a string for the raw tokens.\n *\n * @param  {string}  str\n * @param  {Object=} options\n * @return {!Array}\n */\nfunction parse (str, options) {\n  var tokens = []\n  var key = 0\n  var index = 0\n  var path = ''\n  var defaultDelimiter = options && options.delimiter || '/'\n  var res\n\n  while ((res = PATH_REGEXP.exec(str)) != null) {\n    var m = res[0]\n    var escaped = res[1]\n    var offset = res.index\n    path += str.slice(index, offset)\n    index = offset + m.length\n\n    // Ignore already escaped sequences.\n    if (escaped) {\n      path += escaped[1]\n      continue\n    }\n\n    var next = str[index]\n    var prefix = res[2]\n    var name = res[3]\n    var capture = res[4]\n    var group = res[5]\n    var modifier = res[6]\n    var asterisk = res[7]\n\n    // Push the current path onto the tokens.\n    if (path) {\n      tokens.push(path)\n      path = ''\n    }\n\n    var partial = prefix != null && next != null && next !== prefix\n    var repeat = modifier === '+' || modifier === '*'\n    var optional = modifier === '?' || modifier === '*'\n    var delimiter = res[2] || defaultDelimiter\n    var pattern = capture || group\n\n    tokens.push({\n      name: name || key++,\n      prefix: prefix || '',\n      delimiter: delimiter,\n      optional: optional,\n      repeat: repeat,\n      partial: partial,\n      asterisk: !!asterisk,\n      pattern: pattern ? escapeGroup(pattern) : (asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?')\n    })\n  }\n\n  // Match any characters still remaining.\n  if (index < str.length) {\n    path += str.substr(index)\n  }\n\n  // If the path exists, push it onto the end.\n  if (path) {\n    tokens.push(path)\n  }\n\n  return tokens\n}\n\n/**\n * Compile a string to a template function for the path.\n *\n * @param  {string}             str\n * @param  {Object=}            options\n * @return {!function(Object=, Object=)}\n */\nfunction compile (str, options) {\n  return tokensToFunction(parse(str, options), options)\n}\n\n/**\n * Prettier encoding of URI path segments.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeURIComponentPretty (str) {\n  return encodeURI(str).replace(/[\\/?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Encode the asterisk parameter. Similar to `pretty`, but allows slashes.\n *\n * @param  {string}\n * @return {string}\n */\nfunction encodeAsterisk (str) {\n  return encodeURI(str).replace(/[?#]/g, function (c) {\n    return '%' + c.charCodeAt(0).toString(16).toUpperCase()\n  })\n}\n\n/**\n * Expose a method for transforming tokens into the path function.\n */\nfunction tokensToFunction (tokens, options) {\n  // Compile all the tokens into regexps.\n  var matches = new Array(tokens.length)\n\n  // Compile all the patterns before compilation.\n  for (var i = 0; i < tokens.length; i++) {\n    if (typeof tokens[i] === 'object') {\n      matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$', flags(options))\n    }\n  }\n\n  return function (obj, opts) {\n    var path = ''\n    var data = obj || {}\n    var options = opts || {}\n    var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent\n\n    for (var i = 0; i < tokens.length; i++) {\n      var token = tokens[i]\n\n      if (typeof token === 'string') {\n        path += token\n\n        continue\n      }\n\n      var value = data[token.name]\n      var segment\n\n      if (value == null) {\n        if (token.optional) {\n          // Prepend partial segment prefixes.\n          if (token.partial) {\n            path += token.prefix\n          }\n\n          continue\n        } else {\n          throw new TypeError('Expected \"' + token.name + '\" to be defined')\n        }\n      }\n\n      if (isarray(value)) {\n        if (!token.repeat) {\n          throw new TypeError('Expected \"' + token.name + '\" to not repeat, but received `' + JSON.stringify(value) + '`')\n        }\n\n        if (value.length === 0) {\n          if (token.optional) {\n            continue\n          } else {\n            throw new TypeError('Expected \"' + token.name + '\" to not be empty')\n          }\n        }\n\n        for (var j = 0; j < value.length; j++) {\n          segment = encode(value[j])\n\n          if (!matches[i].test(segment)) {\n            throw new TypeError('Expected all \"' + token.name + '\" to match \"' + token.pattern + '\", but received `' + JSON.stringify(segment) + '`')\n          }\n\n          path += (j === 0 ? token.prefix : token.delimiter) + segment\n        }\n\n        continue\n      }\n\n      segment = token.asterisk ? encodeAsterisk(value) : encode(value)\n\n      if (!matches[i].test(segment)) {\n        throw new TypeError('Expected \"' + token.name + '\" to match \"' + token.pattern + '\", but received \"' + segment + '\"')\n      }\n\n      path += token.prefix + segment\n    }\n\n    return path\n  }\n}\n\n/**\n * Escape a regular expression string.\n *\n * @param  {string} str\n * @return {string}\n */\nfunction escapeString (str) {\n  return str.replace(/([.+*?=^!:${}()[\\]|\\/\\\\])/g, '\\\\$1')\n}\n\n/**\n * Escape the capturing group by escaping special characters and meaning.\n *\n * @param  {string} group\n * @return {string}\n */\nfunction escapeGroup (group) {\n  return group.replace(/([=!:$\\/()])/g, '\\\\$1')\n}\n\n/**\n * Attach the keys as a property of the regexp.\n *\n * @param  {!RegExp} re\n * @param  {Array}   keys\n * @return {!RegExp}\n */\nfunction attachKeys (re, keys) {\n  re.keys = keys\n  return re\n}\n\n/**\n * Get the flags for a regexp from the options.\n *\n * @param  {Object} options\n * @return {string}\n */\nfunction flags (options) {\n  return options && options.sensitive ? '' : 'i'\n}\n\n/**\n * Pull out keys from a regexp.\n *\n * @param  {!RegExp} path\n * @param  {!Array}  keys\n * @return {!RegExp}\n */\nfunction regexpToRegexp (path, keys) {\n  // Use a negative lookahead to match only capturing groups.\n  var groups = path.source.match(/\\((?!\\?)/g)\n\n  if (groups) {\n    for (var i = 0; i < groups.length; i++) {\n      keys.push({\n        name: i,\n        prefix: null,\n        delimiter: null,\n        optional: false,\n        repeat: false,\n        partial: false,\n        asterisk: false,\n        pattern: null\n      })\n    }\n  }\n\n  return attachKeys(path, keys)\n}\n\n/**\n * Transform an array into a regexp.\n *\n * @param  {!Array}  path\n * @param  {Array}   keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction arrayToRegexp (path, keys, options) {\n  var parts = []\n\n  for (var i = 0; i < path.length; i++) {\n    parts.push(pathToRegexp(path[i], keys, options).source)\n  }\n\n  var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options))\n\n  return attachKeys(regexp, keys)\n}\n\n/**\n * Create a path regexp from string input.\n *\n * @param  {string}  path\n * @param  {!Array}  keys\n * @param  {!Object} options\n * @return {!RegExp}\n */\nfunction stringToRegexp (path, keys, options) {\n  return tokensToRegExp(parse(path, options), keys, options)\n}\n\n/**\n * Expose a function for taking tokens and returning a RegExp.\n *\n * @param  {!Array}          tokens\n * @param  {(Array|Object)=} keys\n * @param  {Object=}         options\n * @return {!RegExp}\n */\nfunction tokensToRegExp (tokens, keys, options) {\n  if (!isarray(keys)) {\n    options = /** @type {!Object} */ (keys || options)\n    keys = []\n  }\n\n  options = options || {}\n\n  var strict = options.strict\n  var end = options.end !== false\n  var route = ''\n\n  // Iterate over the tokens and create our regexp string.\n  for (var i = 0; i < tokens.length; i++) {\n    var token = tokens[i]\n\n    if (typeof token === 'string') {\n      route += escapeString(token)\n    } else {\n      var prefix = escapeString(token.prefix)\n      var capture = '(?:' + token.pattern + ')'\n\n      keys.push(token)\n\n      if (token.repeat) {\n        capture += '(?:' + prefix + capture + ')*'\n      }\n\n      if (token.optional) {\n        if (!token.partial) {\n          capture = '(?:' + prefix + '(' + capture + '))?'\n        } else {\n          capture = prefix + '(' + capture + ')?'\n        }\n      } else {\n        capture = prefix + '(' + capture + ')'\n      }\n\n      route += capture\n    }\n  }\n\n  var delimiter = escapeString(options.delimiter || '/')\n  var endsWithDelimiter = route.slice(-delimiter.length) === delimiter\n\n  // In non-strict mode we allow a slash at the end of match. If the path to\n  // match already ends with a slash, we remove it for consistency. The slash\n  // is valid at the end of a path match, not in the middle. This is important\n  // in non-ending mode, where \"/test/\" shouldn't match \"/test//route\".\n  if (!strict) {\n    route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?'\n  }\n\n  if (end) {\n    route += '$'\n  } else {\n    // In non-ending mode, we need the capturing groups to match as much as\n    // possible by using a positive lookahead to the end or next path segment.\n    route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)'\n  }\n\n  return attachKeys(new RegExp('^' + route, flags(options)), keys)\n}\n\n/**\n * Normalize the given path string, returning a regular expression.\n *\n * An empty array can be passed in for the keys, which will hold the\n * placeholder key descriptions. For example, using `/user/:id`, `keys` will\n * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.\n *\n * @param  {(string|RegExp|Array)} path\n * @param  {(Array|Object)=}       keys\n * @param  {Object=}               options\n * @return {!RegExp}\n */\nfunction pathToRegexp (path, keys, options) {\n  if (!isarray(keys)) {\n    options = /** @type {!Object} */ (keys || options)\n    keys = []\n  }\n\n  options = options || {}\n\n  if (path instanceof RegExp) {\n    return regexpToRegexp(path, /** @type {!Array} */ (keys))\n  }\n\n  if (isarray(path)) {\n    return arrayToRegexp(/** @type {!Array} */ (path), /** @type {!Array} */ (keys), options)\n  }\n\n  return stringToRegexp(/** @type {string} */ (path), /** @type {!Array} */ (keys), options)\n}\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\nfunction emptyFunctionWithReset() {}\nemptyFunctionWithReset.resetWarningCache = emptyFunction;\n\nmodule.exports = function() {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\n    var err = new Error(\n      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n      'Use PropTypes.checkPropTypes() to call them. ' +\n      'Read more at http://fb.me/use-check-prop-types'\n    );\n    err.name = 'Invariant Violation';\n    throw err;\n  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  var ReactPropTypes = {\n    array: shim,\n    bigint: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    elementType: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim,\n\n    checkPropTypes: emptyFunctionWithReset,\n    resetWarningCache: emptyFunction\n  };\n\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactIs = require('react-is');\n\n  // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n","/** @license React v16.14.0\n * react.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';var l=require(\"object-assign\"),n=\"function\"===typeof Symbol&&Symbol.for,p=n?Symbol.for(\"react.element\"):60103,q=n?Symbol.for(\"react.portal\"):60106,r=n?Symbol.for(\"react.fragment\"):60107,t=n?Symbol.for(\"react.strict_mode\"):60108,u=n?Symbol.for(\"react.profiler\"):60114,v=n?Symbol.for(\"react.provider\"):60109,w=n?Symbol.for(\"react.context\"):60110,x=n?Symbol.for(\"react.forward_ref\"):60112,y=n?Symbol.for(\"react.suspense\"):60113,z=n?Symbol.for(\"react.memo\"):60115,A=n?Symbol.for(\"react.lazy\"):\n60116,B=\"function\"===typeof Symbol&&Symbol.iterator;function C(a){for(var b=\"https://reactjs.org/docs/error-decoder.html?invariant=\"+a,c=1;c<arguments.length;c++)b+=\"&args[]=\"+encodeURIComponent(arguments[c]);return\"Minified React error #\"+a+\"; visit \"+b+\" for the full message or use the non-minified dev environment for full errors and additional helpful warnings.\"}\nvar D={isMounted:function(){return!1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},E={};function F(a,b,c){this.props=a;this.context=b;this.refs=E;this.updater=c||D}F.prototype.isReactComponent={};F.prototype.setState=function(a,b){if(\"object\"!==typeof a&&\"function\"!==typeof a&&null!=a)throw Error(C(85));this.updater.enqueueSetState(this,a,b,\"setState\")};F.prototype.forceUpdate=function(a){this.updater.enqueueForceUpdate(this,a,\"forceUpdate\")};\nfunction G(){}G.prototype=F.prototype;function H(a,b,c){this.props=a;this.context=b;this.refs=E;this.updater=c||D}var I=H.prototype=new G;I.constructor=H;l(I,F.prototype);I.isPureReactComponent=!0;var J={current:null},K=Object.prototype.hasOwnProperty,L={key:!0,ref:!0,__self:!0,__source:!0};\nfunction M(a,b,c){var e,d={},g=null,k=null;if(null!=b)for(e in void 0!==b.ref&&(k=b.ref),void 0!==b.key&&(g=\"\"+b.key),b)K.call(b,e)&&!L.hasOwnProperty(e)&&(d[e]=b[e]);var f=arguments.length-2;if(1===f)d.children=c;else if(1<f){for(var h=Array(f),m=0;m<f;m++)h[m]=arguments[m+2];d.children=h}if(a&&a.defaultProps)for(e in f=a.defaultProps,f)void 0===d[e]&&(d[e]=f[e]);return{$$typeof:p,type:a,key:g,ref:k,props:d,_owner:J.current}}\nfunction N(a,b){return{$$typeof:p,type:a.type,key:b,ref:a.ref,props:a.props,_owner:a._owner}}function O(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===p}function escape(a){var b={\"=\":\"=0\",\":\":\"=2\"};return\"$\"+(\"\"+a).replace(/[=:]/g,function(a){return b[a]})}var P=/\\/+/g,Q=[];function R(a,b,c,e){if(Q.length){var d=Q.pop();d.result=a;d.keyPrefix=b;d.func=c;d.context=e;d.count=0;return d}return{result:a,keyPrefix:b,func:c,context:e,count:0}}\nfunction S(a){a.result=null;a.keyPrefix=null;a.func=null;a.context=null;a.count=0;10>Q.length&&Q.push(a)}\nfunction T(a,b,c,e){var d=typeof a;if(\"undefined\"===d||\"boolean\"===d)a=null;var g=!1;if(null===a)g=!0;else switch(d){case \"string\":case \"number\":g=!0;break;case \"object\":switch(a.$$typeof){case p:case q:g=!0}}if(g)return c(e,a,\"\"===b?\".\"+U(a,0):b),1;g=0;b=\"\"===b?\".\":b+\":\";if(Array.isArray(a))for(var k=0;k<a.length;k++){d=a[k];var f=b+U(d,k);g+=T(d,f,c,e)}else if(null===a||\"object\"!==typeof a?f=null:(f=B&&a[B]||a[\"@@iterator\"],f=\"function\"===typeof f?f:null),\"function\"===typeof f)for(a=f.call(a),k=\n0;!(d=a.next()).done;)d=d.value,f=b+U(d,k++),g+=T(d,f,c,e);else if(\"object\"===d)throw c=\"\"+a,Error(C(31,\"[object Object]\"===c?\"object with keys {\"+Object.keys(a).join(\", \")+\"}\":c,\"\"));return g}function V(a,b,c){return null==a?0:T(a,\"\",b,c)}function U(a,b){return\"object\"===typeof a&&null!==a&&null!=a.key?escape(a.key):b.toString(36)}function W(a,b){a.func.call(a.context,b,a.count++)}\nfunction aa(a,b,c){var e=a.result,d=a.keyPrefix;a=a.func.call(a.context,b,a.count++);Array.isArray(a)?X(a,e,c,function(a){return a}):null!=a&&(O(a)&&(a=N(a,d+(!a.key||b&&b.key===a.key?\"\":(\"\"+a.key).replace(P,\"$&/\")+\"/\")+c)),e.push(a))}function X(a,b,c,e,d){var g=\"\";null!=c&&(g=(\"\"+c).replace(P,\"$&/\")+\"/\");b=R(b,g,e,d);V(a,aa,b);S(b)}var Y={current:null};function Z(){var a=Y.current;if(null===a)throw Error(C(321));return a}\nvar ba={ReactCurrentDispatcher:Y,ReactCurrentBatchConfig:{suspense:null},ReactCurrentOwner:J,IsSomeRendererActing:{current:!1},assign:l};exports.Children={map:function(a,b,c){if(null==a)return a;var e=[];X(a,e,null,b,c);return e},forEach:function(a,b,c){if(null==a)return a;b=R(null,null,b,c);V(a,W,b);S(b)},count:function(a){return V(a,function(){return null},null)},toArray:function(a){var b=[];X(a,b,null,function(a){return a});return b},only:function(a){if(!O(a))throw Error(C(143));return a}};\nexports.Component=F;exports.Fragment=r;exports.Profiler=u;exports.PureComponent=H;exports.StrictMode=t;exports.Suspense=y;exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=ba;\nexports.cloneElement=function(a,b,c){if(null===a||void 0===a)throw Error(C(267,a));var e=l({},a.props),d=a.key,g=a.ref,k=a._owner;if(null!=b){void 0!==b.ref&&(g=b.ref,k=J.current);void 0!==b.key&&(d=\"\"+b.key);if(a.type&&a.type.defaultProps)var f=a.type.defaultProps;for(h in b)K.call(b,h)&&!L.hasOwnProperty(h)&&(e[h]=void 0===b[h]&&void 0!==f?f[h]:b[h])}var h=arguments.length-2;if(1===h)e.children=c;else if(1<h){f=Array(h);for(var m=0;m<h;m++)f[m]=arguments[m+2];e.children=f}return{$$typeof:p,type:a.type,\nkey:d,ref:g,props:e,_owner:k}};exports.createContext=function(a,b){void 0===b&&(b=null);a={$$typeof:w,_calculateChangedBits:b,_currentValue:a,_currentValue2:a,_threadCount:0,Provider:null,Consumer:null};a.Provider={$$typeof:v,_context:a};return a.Consumer=a};exports.createElement=M;exports.createFactory=function(a){var b=M.bind(null,a);b.type=a;return b};exports.createRef=function(){return{current:null}};exports.forwardRef=function(a){return{$$typeof:x,render:a}};exports.isValidElement=O;\nexports.lazy=function(a){return{$$typeof:A,_ctor:a,_status:-1,_result:null}};exports.memo=function(a,b){return{$$typeof:z,type:a,compare:void 0===b?null:b}};exports.useCallback=function(a,b){return Z().useCallback(a,b)};exports.useContext=function(a,b){return Z().useContext(a,b)};exports.useDebugValue=function(){};exports.useEffect=function(a,b){return Z().useEffect(a,b)};exports.useImperativeHandle=function(a,b,c){return Z().useImperativeHandle(a,b,c)};\nexports.useLayoutEffect=function(a,b){return Z().useLayoutEffect(a,b)};exports.useMemo=function(a,b){return Z().useMemo(a,b)};exports.useReducer=function(a,b,c){return Z().useReducer(a,b,c)};exports.useRef=function(a){return Z().useRef(a)};exports.useState=function(a){return Z().useState(a)};exports.version=\"16.14.0\";\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react.production.min.js');\n} else {\n  module.exports = require('./cjs/react.development.js');\n}\n","var isProduction = process.env.NODE_ENV === 'production';\nvar prefix = 'Invariant failed';\nfunction invariant(condition, message) {\n    if (condition) {\n        return;\n    }\n    if (isProduction) {\n        throw new Error(prefix);\n    }\n    var provided = typeof message === 'function' ? message() : message;\n    var value = provided ? prefix + \": \" + provided : prefix;\n    throw new Error(value);\n}\n\nexport { invariant as default };\n","export default function _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}","import setPrototypeOf from \"./setPrototypeOf.js\";\nexport default function _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  setPrototypeOf(subClass, superClass);\n}","export default function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}","export default function _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}"],"names":["getSdkMetadataForEnvelopeHeader","metadata","sdk","name","version","createEventEnvelope","event","dsn","tunnel","sdkInfo","eventType","type","integrations","packages","enhanceEventWithSdkInfo","envelopeHeaders","dynamicSamplingContext","sdkProcessingMetadata","event_id","sent_at","Date","toISOString","trace","createEventEnvelopeHeaders","eventItem","ALREADY_SEEN_ERROR","BaseClient","__init","this","_integrations","__init2","_integrationsInitialized","__init3","_numProcessing","__init4","_outcomes","constructor","options","prototype","call","_options","_dsn","url","_transport","transport","recordDroppedEvent","bind","transportOptions","__SENTRY_DEBUG__","logger","captureException","exception","hint","scope","log","eventId","_process","eventFromException","then","_captureEvent","result","captureMessage","message","level","promisedEvent","is","eventFromMessage","String","captureEvent","originalException","captureSession","session","_isEnabled","release","sendSession","init","getDsn","getOptions","getTransport","flush","timeout","_isClientDoneProcessing","clientFinished","transportFlushed","close","enabled","setupIntegrations","getIntegrationById","integrationId","getIntegration","integration","id","_oO","sendEvent","env","_metadata","attachment","attachments","textEncoder","_sendEnvelope","envelopeItem","createSessionEnvelope","reason","category","sendClientReports","key","_updateSessionFromEvent","crashed","errored","exceptions","values","ex","mechanism","handled","sessionNonTerminal","status","errors","Number","resolve","ticked","interval","setInterval","clearInterval","undefined","_prepareEvent","normalizeDepth","normalizeMaxBreadth","prepared","timestamp","_applyClientOptions","_applyIntegrationsMetadata","finalScope","captureContext","update","getAttachments","length","applyToEvent","evt","_normalizeEvent","depth","maxBreadth","normalized","breadcrumbs","map","b","data","normalize","user","contexts","extra","spans","span","environment","dist","maxValueLength","value","request","integrationsArray","Object","keys","_processEvent","finalEvent","sentryError","logLevel","beforeSend","sampleRate","isTransaction","Math","random","__sentry__","rv","nullErr","e","_ensureBeforeSendRv","processedEvent","getSession","transactionInfo","transaction_info","transaction","source","changes","propagations","promise","envelope","send","_clearOutcomes","outcomes","split","quantity","BrowserClient","super","_flushOutcomes","stackParser","attachStacktrace","breadcrumbIntegration","sentry","addBreadcrumb","platform","discarded_events","clientReportItem","createClientReportEnvelope","isRealNavigator","toString","sendBeacon","exceptionFromError","frames","parseStackFrames","extractMessage","stacktrace","eventFromError","stack","popSize","framesToPop","reactMinifiedRegexp","test","getPopSize","error","eventFromUnknownInput","syntheticException","eventFromString","isUnhandledRejection","domException","tags","code","client","getClient","__serialized__","eventFromPlainObject","synthetic","input","ignoreOnError","shouldIgnoreOnError","ignoreNextOnError","setTimeout","wrap","fn","before","wrapper","__sentry_wrapped__","sentryWrapped","args","Array","slice","arguments","apply","wrappedArguments","arg","addEventProcessor","property","hasOwnProperty","getOwnPropertyDescriptor","configurable","defineProperty","get","validSeverityLevels","severityLevelFromString","includes","BREADCRUMB_INTEGRATION_ID","Breadcrumbs","static","console","dom","fetch","history","xhr","setupOnce","_consoleBreadcrumb","_innerDomBreadcrumb","handlerData","target","keyAttrs","serializeAttribute","global","_domBreadcrumb","_xhrBreadcrumb","_fetchBreadcrumb","_historyBreadcrumb","breadcrumb","endTimestamp","__sentry_own_request__","method","status_code","body","__sentry_xhr__","fetchData","match","response","from","to","parsedLoc","parsedFrom","parsedTo","path","protocol","host","relative","__initStatic","Dedupe","addGlobalEventProcessor","getCurrentHub","eventProcessor","currentEvent","self","previousEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","_isSameMessageEvent","previousException","_getExceptionFromEvent","currentException","_isSameExceptionEvent","_shouldDropEvent","_previousEvent","currentFrames","_getFramesFromEvent","previousFrames","i","frameA","frameB","filename","lineno","colno","function","currentFingerprint","fingerprint","previousFingerprint","join","GlobalHandlers","_installFunc","onerror","_installGlobalOnErrorHandler","onunhandledrejection","_installGlobalOnUnhandledRejectionHandler","Error","stackTraceLimit","installFunc","hub","getHubAndOptions","msg","line","column","ERROR_TYPES_RE","groups","_enhanceEventWithInitialFrame","_eventFromIncompleteOnError","addMechanismAndCapture","detail","ev","ev0","ev0s","ev0sf","isNaN","parseInt","push","in_app","HttpContext","referrer","userAgent","headers","Referer","LinkedErrors","_key","_limit","limit","parser","linkedErrors","_walkErrorTree","_handler","DEFAULT_EVENT_TARGET","TryCatch","XMLHttpRequest","eventTarget","requestAnimationFrame","_wrapTimeFunction","_wrapRAF","_wrapXHR","eventTargetOption","isArray","forEach","_wrapEventTarget","original","originalCallback","callback","handler","originalSend","prop","wrapOptions","originalFunction","globalObject","proto","eventName","handleEvent","err","originalRemoveEventListener","wrappedEventHandler","originalEventHandler","defaultIntegrations","autoSessionTracking","clientOptions","supports","clientClass","debug","warn","getScope","initialScope","bindClient","initAndBind","startSessionOnHub","startSessionTracking","showReportDialog","getStackTop","getUser","lastEventId","script","async","src","onLoad","onload","injectionPoint","appendChild","forceLoad","startSession","ignoreDuration","UNKNOWN_FUNCTION","createFrame","func","frame","chromeRegex","chromeEvalRegex","chromeStackLineParser","parts","exec","indexOf","subMatch","extractSafariExtensionDetails","geckoREgex","geckoEvalRegex","geckoStackLineParser","winjsRegex","winjsStackLineParser","opera10Regex","opera10StackLineParser","opera11Regex","opera11StackLineParser","defaultStackLineParsers","defaultStackParser","isSafariExtension","isSafariWebExtension","cachedFetchImpl","makeFetchTransport","nativeFetch","document","fetchImpl","createElement","sandbox","hidden","head","contentWindow","removeChild","getNativeFetchImplementation","requestOptions","referrerPolicy","keepalive","fetchOptions","statusCode","makeXHRTransport","reject","onreadystatechange","readyState","getResponseHeader","open","header","setRequestHeader","getBaseApiEndpoint","port","getEnvelopeEndpointWithUrlEncodedAuth","tunnelOrOptions","projectId","_getIngestEndpoint","sentry_key","publicKey","sentry_version","sentry_client","_encodedAuth","getReportDialogEndpoint","dsnLike","dialogOptions","endpoint","encodedOptions","encodeURIComponent","email","context","configureScope","setContext","setExtras","extras","setExtra","setTags","setTag","setUser","withScope","startTransaction","customSamplingContext","DEFAULT_BREADCRUMBS","Hub","_stack","_version","isOlderThan","pushScope","getStack","popScope","pop","_lastEventId","_withClient","beforeBreadcrumb","maxBreadcrumbs","mergedBreadcrumb","finalBreadcrumb","run","oldHub","makeMain","_callExtensionMethod","traceHeaders","endSession","_sendSessionUpdate","layer","setSession","currentSession","shouldSendDefaultPii","Boolean","sendDefaultPii","getMainCarrier","__SENTRY__","extensions","registry","getHubFromCarrier","setHubOnCarrier","hasHubOnCarrier","activeDomain","domain","active","registryHubTopStack","_Oo","getHubFromActiveDomain","carrier","installedIntegrations","getIntegrationsToSetup","userIntegrations","isDefaultInstance","finalIntegrations","integrationsByName","currentInstance","existingInstance","filterDuplicates","debugIndex","findIndex","debugInstance","splice","integrationIndex","originalFunctionToString","FunctionToString","Function","DEFAULT_IGNORE_ERRORS","InboundFilters","eventProcess","internalOptions","allowUrls","denyUrls","ignoreErrors","ignoreInternal","_mergeOptions","_isSentryError","oO","_getPossibleEventMessages","some","pattern","_isIgnoredError","_getEventFilterUrl","_isDeniedUrl","_isAllowedUrl","_getLastValidUrl","Scope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_attachments","_user","_tags","_extra","_contexts","_sdkProcessingMetadata","newScope","_level","_span","_session","_transactionName","_fingerprint","_requestSession","addScopeListener","_notifyScopeListeners","getRequestSession","setRequestSession","requestSession","setFingerprint","setLevel","setTransactionName","setSpan","getSpan","getTransaction","updatedScope","clear","maxCrumbs","clearBreadcrumbs","addAttachment","clearAttachments","getTraceContext","transactionName","_applyFingerprint","_notifyEventProcessors","getGlobalEventProcessors","setSDKProcessingMetadata","newData","processors","index","processor","final","concat","makeSession","startingTime","sid","started","duration","toJSON","did","attrs","ip_address","ipAddress","user_agent","sessionToJSON","updateSession","username","closeSession","makePromiseBuffer","buffer","remove","task","$","add","taskProducer","drain","counter","capturedSetTimeout","item","clearTimeout","updateRateLimits","limits","now","updatedRateLimits","rateLimitHeader","retryAfterHeader","trim","retryAfter","categories","headerDelay","delay","all","headerDate","parse","parseRetryAfterHeader","createTransport","makeRequest","bufferSize","rateLimits","filteredEnvelopeItems","envelopeItemDataCategory","disabledUntil","isRateLimited","filteredEnvelope","recordEnvelopeLoss","_","SDK_VERSION","windowIntegrations","INTEGRATIONS","REACT_RENDER_OP","REACT_MOUNT_OP","_jsxFileName","Profiler","_mountSpan","_updateSpan","defaultProps","disabled","includeRender","includeUpdates","props","activeTransaction","getActiveTransaction","startChild","description","op","componentDidMount","finish","shouldComponentUpdate","updateProps","changedProps","filter","k","time","startTimestamp","componentDidUpdate","componentWillUnmount","render","children","withProfiler","WrappedComponent","componentDisplayName","displayName","Wrapped","__self","__source","fileName","lineNumber","useProfiler","hasRenderSpan","mountSpan","INITIAL_STATE","componentStack","ErrorBoundary","state","componentDidCatch","beforeCapture","onError","showDialog","major","isAtLeastReact17","errorBoundaryError","cause","react","setState","onMount","onUnmount","resetErrorBoundary","onReset","fallback","element","resetError","withErrorBoundary","errorBoundaryOptions","defaultOptions","actionTransformer","action","stateTransformer","createReduxEnhancer","enhancerOptions","next","reducer","initialState","newState","transformedAction","transformedState","configureScopeWithState","reactRouterV3Instrumentation","routes","startTransactionOnPageLoad","startTransactionOnLocationChange","prevName","normalizeTransactionName","localName","listen","location","appRoutes","pathname","_redirectLocation","renderProps","routePath","routesWithPaths","route","x","startsWith","getRouteStringFromRoutes","_useEffect","_useLocation","_useNavigationType","_createRoutesFromChildren","_matchRoutes","_customStartTransaction","_startTransactionOnLocationChange","SENTRY_TAGS","reactRouterV6Instrumentation","useEffect","useLocation","useNavigationType","createRoutesFromChildren","matchRoutes","customStartTransaction","initPathName","getNormalizedName","branches","pathBuilder","branch","newPath","updatePageloadTransaction","setName","handleNavigation","navigationType","isBaseLocation","withSentryReactRouterV6Routing","Routes","SentryRoutes","wrapUseRoutes","origUseRoutes","locationObject","reactRouterV4Instrumentation","matchPath","createReactRouterInstrumentation","reactRouterV5Instrumentation","allRoutes","isExact","params","computeRootMatch","withSentryRouting","Route","WrappedRoute","computedMatch","errorCallback","setStatus","toTraceparent","sample","samplingContext","sampled","setMetadata","tracesSampler","parentSampled","tracesSampleRate","rate","JSON","stringify","isValidSampleRate","_startTransaction","transactionContext","initSpanRecorder","_experiments","startIdleTransaction","idleTimeout","finalTimeout","onScope","heartbeatInterval","addExtensionMethods","_addTracingExtensions","packageToIntegrationMapping","mongodb","module","Mongo","mongoose","mysql","Mysql","pg","Postgres","mappedPackages","moduleName","pkg","p","_autoloadDatabaseIntegrations","DEFAULT_IDLE_TIMEOUT","DEFAULT_FINAL_TIMEOUT","DEFAULT_HEARTBEAT_INTERVAL","IdleTransactionSpanRecorder","_pushActivity","_popActivity","transactionSpanId","maxlen","spanId","IdleTransaction","activities","_heartbeatCounter","_finished","_beforeFinishCallbacks","_idleHub","_idleTimeout","_finalTimeout","_heartbeatInterval","_onScope","clearActiveTransaction","_startIdleTimeout","spanRecorder","keepSpan","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","object","entries","reduce","baggageHeader","objectKey","objectValue","currentIndex","baggageEntry","newBaggageHeader","objectToBaggageHeader","acc","dscKey","dscValue","baggageHeaderToObject","keyOrValue","decodeURIComponent","bindReporter","metric","reportAllChanges","prevValue","forceReport","delta","initMetric","_nullishCoalesce","floor","observe","PerformanceObserver","supportedEntryTypes","po","l","getEntries","buffered","onHidden","cb","once","onHiddenOrPageHide","removeEventListener","addEventListener","firstHiddenTime","getVisibilityWatcher","Infinity","timeStamp","reportedMetricIDs","isMeasurementValue","isFinite","_startChild","ctx","getBrowserPerformanceAPI","_lcpEntry","_clsEntry","_performanceCursor","_measurements","startTrackingWebVitals","performance","mark","onReport","report","sessionValue","sessionEntries","entryHandler","entry","hadRecentInput","firstSessionEntry","lastSessionEntry","startTime","takeRecords","getCLS","unit","visibilityWatcher","stopListening","disconnect","capture","getLCP","_trackLCP","processingStart","getFID","timeOrigin","addPerformanceEntries","performanceEntries","responseStartTimestamp","requestStartTimestamp","entryType","_addPerformanceNavigationTiming","requestStart","responseEnd","responseStart","_addRequest","_addNavigationSpans","measureStartTimestamp","measureEndTimestamp","_addMeasureSpans","firstHidden","shouldRecord","resourceName","replace","initiatorType","transferSize","encodedBodySize","decodedBodySize","_addResourceSpans","max","navigator","connection","effectiveType","rtt","deviceMemory","hardwareConcurrency","_trackNavigator","oldValue","measurementTimestamp","normalizedValue","abs","fidMark","cls","measurementName","setMeasurement","size","sources","node","_tagMetricInfo","eventEnd","end","start","defaultRequestInstrumentationOptions","traceFetch","traceXHR","tracingOrigins","instrumentOutgoingRequests","shouldCreateSpanForRequest","urlMap","defaultShouldCreateSpan","origins","origin","shouldCreateSpan","__span","setHttpStatus","sentryBaggageHeader","sentryTraceHeader","Request","Headers","newHeaders","append","existingBaggageHeader","baggage","newBaggageHeaders","addTracingHeadersToFetchRequest","getDynamicSamplingContext","fetchCallback","__sentry_xhr_span_id__","xhrCallback","DEFAULT_BROWSER_TRACING_OPTIONS","markBackgroundTransactions","routingInstrumentation","startingUrl","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","newMetadata","finishedSpans","s","prev","current","measurements","public_key","maybeSampleRate","sample_rate","segment","user_segment","hasTracingEnabled","maybeOptions","maybeHub","msToSec","WINDOW","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","href","getDomElement","selector","querySelector","lhs","rhsFn","DSN_REGEX","dsnToString","withPassword","pass","dsnFromComponents","components","makeDsn","str","lastPath","projectMatch","dsnFromString","component","isValidProtocol","validateDsn","createEnvelope","items","addItemToEnvelope","newItem","forEachEnvelopeItem","envelopeItemType","encodeUTF8","TextEncoder","encode","serializeEnvelope","envHeaders","itemHeaders","payload","Uint8Array","stringifiedPayload","buffers","totalLength","buf","merged","offset","set","concatBuffers","createAttachmentEnvelopeItem","content_type","contentType","attachment_type","attachmentType","ITEM_TYPE_TO_DATA_CATEGORY_MAP","sessions","client_report","user_report","envelopeItemTypeToDataCategory","SentryError","setPrototypeOf","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","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","maxProperties","visit","ERROR","normalizeToSize","maxSize","encodeURI","utf8Length","memo","hasWeakSet","WeakSet","inner","obj","has","delete","memoBuilder","memoize","unmemoize","stringified","_events","g","window","getPrototypeOf","stringifyValue","valueWithToJSON","numAdded","visitable","visitKey","visitValue","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","States","resolvedSyncPromise","SyncPromise","rejectedSyncPromise","_state","PENDING","_handlers","executor","_resolve","_reject","onfulfilled","onrejected","_executeHandlers","catch","val","finally","onfinally","isRejected","_setResult","RESOLVED","REJECTED","_value","cachedHandlers","dateTimestampSource","nowSeconds","platformPerformance","getNodePerformance","getBrowserPerformance","timestampSource","dateTimestampInSeconds","timestampInSeconds","timestampWithMs","_browserPerformanceTimeOriginMode","browserPerformanceTimeOrigin","threshold","performanceNow","dateNow","timeOriginDelta","timeOriginIsReliable","navigationStart","timing","navigationStartDelta","parseUrl","query","fragment","getNumberOfUrlSegments","isGlobalObj","GLOBAL_OBJ","globalThis","getGlobalSingleton","creator","isAbsolute","charAt","spliceOne","list","n","hasTrailingSlash","toParts","fromParts","isToAbs","isFromAbs","mustEndAbs","last","up","part","unshift","valueOf","valueEqual","every","aValue","bValue","assign","addLeadingSlash","stripLeadingSlash","stripBasename","prefix","hasBasename","stripTrailingSlash","createPath","search","hash","createLocation","currentLocation","hashIndex","searchIndex","parsePath","decodeURI","URIError","locationsAreEqual","createTransitionManager","prompt","listeners","setPrompt","nextPrompt","confirmTransitionTo","getUserConfirmation","appendListener","isActive","notifyListeners","_len","canUseDOM","getConfirmation","confirm","PopStateEvent","HashChangeEvent","getHistoryState","createBrowserHistory","ua","globalHistory","canUseHistory","needsHashChangeListener","_props","_props$forceRefresh","forceRefresh","_props$getUserConfirm","_props$keyLength","keyLength","basename","getDOMLocation","historyState","_ref","_window$location","createKey","transitionManager","nextState","handlePopState","isExtraneousPopstateEvent","handlePop","handleHashChange","forceNextPop","ok","fromLocation","toLocation","toIndex","allKeys","fromIndex","go","revertPop","initialLocation","createHref","listenerCount","checkDOMListeners","isBlocked","pushState","prevIndex","nextKeys","replaceState","goBack","goForward","block","unblock","unlisten","HashChangeEvent$1","HashPathCoders","hashbang","encodePath","decodePath","noslash","slash","stripHash","getHashPath","replaceHashPath","createHashHistory","_props$hashType","hashType","_HashPathCoders$hashT","ignorePath","encodedPath","prevLocation","allPaths","lastIndexOf","baseTag","pushHashPath","nextPaths","clamp","lowerBound","upperBound","min","createMemoryHistory","_props$initialEntries","initialEntries","_props$initialIndex","initialIndex","nextIndex","nextEntries","canGo","reactIs","REACT_STATICS","childContextTypes","contextType","contextTypes","getDefaultProps","getDerivedStateFromError","getDerivedStateFromProps","mixins","propTypes","KNOWN_STATICS","caller","callee","arity","MEMO_STATICS","compare","TYPE_STATICS","getStatics","isMemo","ForwardRef","Memo","getOwnPropertyNames","getOwnPropertySymbols","objectPrototype","exports","hoistNonReactStatics","targetComponent","sourceComponent","blacklist","inheritedComponent","targetStatics","sourceStatics","descriptor","propIsEnumerable","propertyIsEnumerable","toObject","TypeError","test1","test2","fromCharCode","test3","letter","shouldUseNative","symbols","Symbol","for","d","f","h","m","q","r","t","v","w","y","z","u","$$typeof","A","AsyncMode","ConcurrentMode","ContextConsumer","ContextProvider","Fragment","Lazy","Portal","StrictMode","Suspense","isAsyncMode","isConcurrentMode","isContextConsumer","isContextProvider","isForwardRef","isFragment","isLazy","isPortal","isProfiler","isStrictMode","isSuspense","isValidElementType","typeOf","MAX_SIGNED_31_BIT_INT","commonjsGlobal","createEventEmitter","on","off","newValue","changedBits","defaultValue","calculateChangedBits","_Provider$childContex","_Consumer$contextType","contextProp","getUniqueId","Provider","_Component","_this","emitter","_proto","getChildContext","componentWillReceiveProps","nextProps","Component","Consumer","_Component2","_this2","getValue","onUpdate","observedBits","_proto2","createNamedContext","historyContext","Router","_React$Component","_isMounted","_pendingLocation","staticContext","Lifecycle","prevProps","cache","cacheCount","generatePath","generator","compilePath","pretty","Redirect","_ref$push","cache$1","cacheCount$1","_options$exact","exact","_options$strict","strict","_options$sensitive","sensitive","matched","_compilePath","cacheKey","pathCache","regexp","compilePath$1","context$1","_this$props","isEmptyChildren","createURL","staticHandler","methodName","noop","Switch","child","withRouter","C","wrappedComponentRef","remainingProps","ref","useContext","useHistory","arr","isarray","pathToRegexp","compile","tokensToFunction","tokensToRegExp","PATH_REGEXP","res","tokens","defaultDelimiter","escaped","group","modifier","asterisk","partial","repeat","optional","escapeGroup","escapeString","encodeURIComponentPretty","charCodeAt","flags","opts","token","j","attachKeys","re","endsWithDelimiter","regexpToRegexp","arrayToRegexp","stringToRegexp","ReactPropTypesSecret","emptyFunction","emptyFunctionWithReset","resetWarningCache","shim","propName","componentName","propFullName","secret","getShim","isRequired","ReactPropTypes","array","bigint","bool","number","string","symbol","any","arrayOf","elementType","instanceOf","objectOf","oneOf","oneOfType","shape","checkPropTypes","PropTypes","B","iterator","D","isMounted","enqueueForceUpdate","enqueueReplaceState","enqueueSetState","E","F","refs","updater","G","H","isReactComponent","forceUpdate","I","isPureReactComponent","J","K","L","M","_owner","O","P","Q","R","keyPrefix","count","S","T","U","done","V","escape","W","aa","X","N","Y","Z","ba","ReactCurrentDispatcher","ReactCurrentBatchConfig","suspense","ReactCurrentOwner","IsSomeRendererActing","Children","toArray","only","PureComponent","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED","cloneElement","createContext","_calculateChangedBits","_currentValue","_currentValue2","_threadCount","_context","createFactory","createRef","forwardRef","isValidElement","lazy","_ctor","_status","_result","useCallback","useDebugValue","useImperativeHandle","useLayoutEffect","useMemo","useReducer","useRef","useState","invariant","condition","_extends","_inheritsLoose","subClass","superClass","create","_objectWithoutPropertiesLoose","excluded","sourceKeys","_setPrototypeOf","o","__proto__"],"sourceRoot":""}