{"version":3,"file":"js/3948-42f79c4df9d9c399f8b8.js","mappings":"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","sources":["webpack://artfully-walls/./node_modules/@sentry/core/build/esm/api.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/asyncContext/stackStrategy.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/defaultScopes.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/asyncContext/index.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/baseclient.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/breadcrumbs.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/carrier.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/constants.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/currentScopes.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/debug-build.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/envelope.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/eventProcessors.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/exports.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/feedback.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/fetch.js"],"sourcesContent":["import { makeDsn, dsnToString } from './utils-hoist/dsn.js';\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  const params = {\n    sentry_version: SENTRY_API_VERSION,\n  };\n\n  if (dsn.publicKey) {\n    // We send only the minimum set of required information. See\n    // https://github.com/getsentry/sentry-javascript/issues/2572.\n    params.sentry_key = dsn.publicKey;\n  }\n\n  if (sdkInfo) {\n    params.sentry_client = `${sdkInfo.name}/${sdkInfo.version}`;\n  }\n\n  return new URLSearchParams(params).toString();\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(dsn, tunnel, sdkInfo) {\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  if (!dsn) {\n    return '';\n  }\n\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 === 'onClose') {\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 { getDefaultCurrentScope, getDefaultIsolationScope } from '../defaultScopes.js';\nimport { Scope } from '../scope.js';\nimport { isThenable } from '../utils-hoist/is.js';\nimport { getMainCarrier, getSentryCarrier } from '../carrier.js';\n\n/**\n * This is an object that holds a stack of scopes.\n */\nclass AsyncContextStack {\n\n   constructor(scope, isolationScope) {\n    let assignedScope;\n    if (!scope) {\n      assignedScope = new Scope();\n    } else {\n      assignedScope = scope;\n    }\n\n    let assignedIsolationScope;\n    if (!isolationScope) {\n      assignedIsolationScope = new Scope();\n    } else {\n      assignedIsolationScope = isolationScope;\n    }\n\n    // scope stack for domains or the process\n    this._stack = [{ scope: assignedScope }];\n    this._isolationScope = assignedIsolationScope;\n  }\n\n  /**\n   * Fork a scope for the stack.\n   */\n   withScope(callback) {\n    const scope = this._pushScope();\n\n    let maybePromiseResult;\n    try {\n      maybePromiseResult = callback(scope);\n    } catch (e) {\n      this._popScope();\n      throw e;\n    }\n\n    if (isThenable(maybePromiseResult)) {\n      // @ts-expect-error - isThenable returns the wrong type\n      return maybePromiseResult.then(\n        res => {\n          this._popScope();\n          return res;\n        },\n        e => {\n          this._popScope();\n          throw e;\n        },\n      );\n    }\n\n    this._popScope();\n    return maybePromiseResult;\n  }\n\n  /**\n   * Get the client of the stack.\n   */\n   getClient() {\n    return this.getStackTop().client ;\n  }\n\n  /**\n   * Returns the scope of the top stack.\n   */\n   getScope() {\n    return this.getStackTop().scope;\n  }\n\n  /**\n   * Get the isolation scope for the stack.\n   */\n   getIsolationScope() {\n    return this._isolationScope;\n  }\n\n  /**\n   * Returns the topmost scope layer in the order domain > local > process.\n   */\n   getStackTop() {\n    return this._stack[this._stack.length - 1] ;\n  }\n\n  /**\n   * Push a scope to the stack.\n   */\n   _pushScope() {\n    // We want to clone the content of prev scope\n    const scope = this.getScope().clone();\n    this._stack.push({\n      client: this.getClient(),\n      scope,\n    });\n    return scope;\n  }\n\n  /**\n   * Pop a scope from the stack.\n   */\n   _popScope() {\n    if (this._stack.length <= 1) return false;\n    return !!this._stack.pop();\n  }\n}\n\n/**\n * Get the global async context stack.\n * This will be removed during the v8 cycle and is only here to make migration easier.\n */\nfunction getAsyncContextStack() {\n  const registry = getMainCarrier();\n  const sentry = getSentryCarrier(registry);\n\n  return (sentry.stack = sentry.stack || new AsyncContextStack(getDefaultCurrentScope(), getDefaultIsolationScope()));\n}\n\nfunction withScope(callback) {\n  return getAsyncContextStack().withScope(callback);\n}\n\nfunction withSetScope(scope, callback) {\n  const stack = getAsyncContextStack() ;\n  return stack.withScope(() => {\n    stack.getStackTop().scope = scope;\n    return callback(scope);\n  });\n}\n\nfunction withIsolationScope(callback) {\n  return getAsyncContextStack().withScope(() => {\n    return callback(getAsyncContextStack().getIsolationScope());\n  });\n}\n\n/**\n * Get the stack-based async context strategy.\n */\nfunction getStackAsyncContextStrategy() {\n  return {\n    withIsolationScope,\n    withScope,\n    withSetScope,\n    withSetIsolationScope: (_isolationScope, callback) => {\n      return withIsolationScope(callback);\n    },\n    getCurrentScope: () => getAsyncContextStack().getScope(),\n    getIsolationScope: () => getAsyncContextStack().getIsolationScope(),\n  };\n}\n\nexport { AsyncContextStack, getStackAsyncContextStrategy };\n//# sourceMappingURL=stackStrategy.js.map\n","import { Scope } from './scope.js';\nimport { getGlobalSingleton } from './utils-hoist/worldwide.js';\n\n/** Get the default current scope. */\nfunction getDefaultCurrentScope() {\n  return getGlobalSingleton('defaultCurrentScope', () => new Scope());\n}\n\n/** Get the default isolation scope. */\nfunction getDefaultIsolationScope() {\n  return getGlobalSingleton('defaultIsolationScope', () => new Scope());\n}\n\nexport { getDefaultCurrentScope, getDefaultIsolationScope };\n//# sourceMappingURL=defaultScopes.js.map\n","import { getMainCarrier, getSentryCarrier } from '../carrier.js';\nimport { getStackAsyncContextStrategy } from './stackStrategy.js';\n\n/**\n * @private Private API with no semver guarantees!\n *\n * Sets the global async context strategy\n */\nfunction setAsyncContextStrategy(strategy) {\n  // Get main carrier (global for every environment)\n  const registry = getMainCarrier();\n  const sentry = getSentryCarrier(registry);\n  sentry.acs = strategy;\n}\n\n/**\n * Get the current async context strategy.\n * If none has been setup, the default will be used.\n */\nfunction getAsyncContextStrategy(carrier) {\n  const sentry = getSentryCarrier(carrier);\n\n  if (sentry.acs) {\n    return sentry.acs;\n  }\n\n  // Otherwise, use the default one (stack)\n  return getStackAsyncContextStrategy();\n}\n\nexport { getAsyncContextStrategy, setAsyncContextStrategy };\n//# sourceMappingURL=index.js.map\n","import { getEnvelopeEndpointWithUrlEncodedAuth } from './api.js';\nimport { getTraceContextFromScope, getCurrentScope, getIsolationScope } from './currentScopes.js';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { createEventEnvelope, createSessionEnvelope } from './envelope.js';\nimport { setupIntegration, afterSetupIntegrations, setupIntegrations } from './integration.js';\nimport { updateSession } from './session.js';\nimport { getDynamicSamplingContextFromScope } from './tracing/dynamicSamplingContext.js';\nimport { createClientReportEnvelope } from './utils-hoist/clientreport.js';\nimport { makeDsn, dsnToString } from './utils-hoist/dsn.js';\nimport { addItemToEnvelope, createAttachmentEnvelopeItem } from './utils-hoist/envelope.js';\nimport { SentryError } from './utils-hoist/error.js';\nimport { isPrimitive, isThenable, isPlainObject, isParameterizedString } from './utils-hoist/is.js';\nimport { logger, consoleSandbox } from './utils-hoist/logger.js';\nimport { uuid4, checkOrSetAlreadyCaught } from './utils-hoist/misc.js';\nimport { resolvedSyncPromise, SyncPromise, rejectedSyncPromise } from './utils-hoist/syncpromise.js';\nimport { parseSampleRate } from './utils/parseSampleRate.js';\nimport { prepareEvent } from './utils/prepareEvent.js';\nimport { showSpanDropWarning } from './utils/spanUtils.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\n  /** Number of calls being processed */\n\n  /** Holds flushable  */\n\n  // eslint-disable-next-line @typescript-eslint/ban-types\n\n  /**\n   * Initializes this client instance.\n   *\n   * @param options Options for the client.\n   */\n   constructor(options) {\n    this._options = options;\n    this._integrations = {};\n    this._numProcessing = 0;\n    this._outcomes = {};\n    this._hooks = {};\n    this._eventProcessors = [];\n\n    if (options.dsn) {\n      this._dsn = makeDsn(options.dsn);\n    } else {\n      DEBUG_BUILD && logger.warn('No DSN provided, client will not send events.');\n    }\n\n    if (this._dsn) {\n      const url = getEnvelopeEndpointWithUrlEncodedAuth(\n        this._dsn,\n        options.tunnel,\n        options._metadata ? options._metadata.sdk : undefined,\n      );\n      this._transport = options.transport({\n        tunnel: this._options.tunnel,\n        recordDroppedEvent: this.recordDroppedEvent.bind(this),\n        ...options.transportOptions,\n        url,\n      });\n    }\n\n    // TODO(v9): Remove this deprecation warning\n    const tracingOptions = ['enableTracing', 'tracesSampleRate', 'tracesSampler'] ;\n    const undefinedOption = tracingOptions.find(option => option in options && options[option] == undefined);\n    if (undefinedOption) {\n      consoleSandbox(() => {\n        // eslint-disable-next-line no-console\n        console.warn(\n          `[Sentry] Deprecation warning: \\`${undefinedOption}\\` is set to undefined, which leads to tracing being enabled. In v9, a value of \\`undefined\\` will result in tracing being disabled.`,\n        );\n      });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureException(exception, hint, scope) {\n    const eventId = uuid4();\n\n    // ensure we haven't captured this very object before\n    if (checkOrSetAlreadyCaught(exception)) {\n      DEBUG_BUILD && logger.log(ALREADY_SEEN_ERROR);\n      return eventId;\n    }\n\n    const hintWithEventId = {\n      event_id: eventId,\n      ...hint,\n    };\n\n    this._process(\n      this.eventFromException(exception, hintWithEventId).then(event =>\n        this._captureEvent(event, hintWithEventId, scope),\n      ),\n    );\n\n    return hintWithEventId.event_id;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureMessage(\n    message,\n    level,\n    hint,\n    currentScope,\n  ) {\n    const hintWithEventId = {\n      event_id: uuid4(),\n      ...hint,\n    };\n\n    const eventMessage = isParameterizedString(message) ? message : String(message);\n\n    const promisedEvent = isPrimitive(message)\n      ? this.eventFromMessage(eventMessage, level, hintWithEventId)\n      : this.eventFromException(message, hintWithEventId);\n\n    this._process(promisedEvent.then(event => this._captureEvent(event, hintWithEventId, currentScope)));\n\n    return hintWithEventId.event_id;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureEvent(event, hint, currentScope) {\n    const eventId = uuid4();\n\n    // ensure we haven't captured this very object before\n    if (hint && hint.originalException && checkOrSetAlreadyCaught(hint.originalException)) {\n      DEBUG_BUILD && logger.log(ALREADY_SEEN_ERROR);\n      return eventId;\n    }\n\n    const hintWithEventId = {\n      event_id: eventId,\n      ...hint,\n    };\n\n    const sdkProcessingMetadata = event.sdkProcessingMetadata || {};\n    const capturedSpanScope = sdkProcessingMetadata.capturedSpanScope;\n\n    this._process(this._captureEvent(event, hintWithEventId, capturedSpanScope || currentScope));\n\n    return hintWithEventId.event_id;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   captureSession(session) {\n    if (!(typeof session.release === 'string')) {\n      DEBUG_BUILD && 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   * @see SdkMetadata\n   *\n   * @return The metadata of the SDK\n   */\n   getSdkMetadata() {\n    return this._options._metadata;\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      this.emit('flush');\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      this.emit('close');\n      return result;\n    });\n  }\n\n  /** Get all installed event processors. */\n   getEventProcessors() {\n    return this._eventProcessors;\n  }\n\n  /** @inheritDoc */\n   addEventProcessor(eventProcessor) {\n    this._eventProcessors.push(eventProcessor);\n  }\n\n  /** @inheritdoc */\n   init() {\n    if (\n      this._isEnabled() ||\n      // Force integrations to be setup even if no DSN was set when we have\n      // Spotlight enabled. This is particularly important for browser as we\n      // don't support the `spotlight` option there and rely on the users\n      // adding the `spotlightBrowserIntegration()` to their integrations which\n      // wouldn't get initialized with the check below when there's no DSN set.\n      this._options.integrations.some(({ name }) => name.startsWith('Spotlight'))\n    ) {\n      this._setupIntegrations();\n    }\n  }\n\n  /**\n   * Gets an installed integration by its name.\n   *\n   * @returns The installed integration or `undefined` if no integration with that `name` was installed.\n   */\n   getIntegrationByName(integrationName) {\n    return this._integrations[integrationName] ;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   addIntegration(integration) {\n    const isAlreadyInstalled = this._integrations[integration.name];\n\n    // This hook takes care of only installing if not already installed\n    setupIntegration(this, integration, this._integrations);\n    // Here we need to check manually to make sure to not run this multiple times\n    if (!isAlreadyInstalled) {\n      afterSetupIntegrations(this, [integration]);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   sendEvent(event, hint = {}) {\n    this.emit('beforeSendEvent', event, hint);\n\n    let env = createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);\n\n    for (const attachment of hint.attachments || []) {\n      env = addItemToEnvelope(env, createAttachmentEnvelopeItem(attachment));\n    }\n\n    const promise = this.sendEnvelope(env);\n    if (promise) {\n      promise.then(sendResponse => this.emit('afterSendEvent', event, sendResponse), null);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n   sendSession(session) {\n    const env = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);\n\n    // sendEnvelope should not throw\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.sendEnvelope(env);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   recordDroppedEvent(reason, category, eventOrCount) {\n    if (this._options.sendClientReports) {\n      // TODO v9: We do not need the `event` passed as third argument anymore, and can possibly remove this overload\n      // If event is passed as third argument, we assume this is a count of 1\n      const count = typeof eventOrCount === 'number' ? eventOrCount : 1;\n\n      // We want to track each category (error, transaction, session, replay_event) 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      DEBUG_BUILD && logger.log(`Recording outcome: \"${key}\"${count > 1 ? ` (${count} times)` : ''}`);\n      this._outcomes[key] = (this._outcomes[key] || 0) + count;\n    }\n  }\n\n  // Keep on() & emit() signatures in sync with types' client.ts interface\n  /* eslint-disable @typescript-eslint/unified-signatures */\n\n  /** @inheritdoc */\n\n  /** @inheritdoc */\n   on(hook, callback) {\n    const hooks = (this._hooks[hook] = this._hooks[hook] || []);\n\n    // @ts-expect-error We assume the types are correct\n    hooks.push(callback);\n\n    // This function returns a callback execution handler that, when invoked,\n    // deregisters a callback. This is crucial for managing instances where callbacks\n    // need to be unregistered to prevent self-referencing in callback closures,\n    // ensuring proper garbage collection.\n    return () => {\n      // @ts-expect-error We assume the types are correct\n      const cbIndex = hooks.indexOf(callback);\n      if (cbIndex > -1) {\n        hooks.splice(cbIndex, 1);\n      }\n    };\n  }\n\n  /** @inheritdoc */\n\n  /** @inheritdoc */\n   emit(hook, ...rest) {\n    const callbacks = this._hooks[hook];\n    if (callbacks) {\n      callbacks.forEach(callback => callback(...rest));\n    }\n  }\n\n  /**\n   * @inheritdoc\n   */\n   sendEnvelope(envelope) {\n    this.emit('beforeEnvelope', envelope);\n\n    if (this._isEnabled() && this._transport) {\n      return this._transport.send(envelope).then(null, reason => {\n        DEBUG_BUILD && logger.error('Error while sending envelope:', reason);\n        return reason;\n      });\n    }\n\n    DEBUG_BUILD && logger.error('Transport disabled');\n\n    return resolvedSyncPromise({});\n  }\n\n  /* eslint-enable @typescript-eslint/unified-signatures */\n\n  /** Setup integrations for this client. */\n   _setupIntegrations() {\n    const { integrations } = this._options;\n    this._integrations = setupIntegrations(this, integrations);\n    afterSetupIntegrations(this, integrations);\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 transport is present. */\n   _isEnabled() {\n    return this.getOptions().enabled !== false && this._transport !== 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 currentScope A scope containing event metadata.\n   * @returns A new event with more information.\n   */\n   _prepareEvent(\n    event,\n    hint,\n    currentScope = getCurrentScope(),\n    isolationScope = getIsolationScope(),\n  ) {\n    const options = this.getOptions();\n    const integrations = Object.keys(this._integrations);\n    if (!hint.integrations && integrations.length > 0) {\n      hint.integrations = integrations;\n    }\n\n    this.emit('preprocessEvent', event, hint);\n\n    if (!event.type) {\n      isolationScope.setLastEventId(event.event_id || hint.event_id);\n    }\n\n    return prepareEvent(options, event, hint, currentScope, this, isolationScope).then(evt => {\n      if (evt === null) {\n        return evt;\n      }\n\n      evt.contexts = {\n        trace: getTraceContextFromScope(currentScope),\n        ...evt.contexts,\n      };\n\n      const dynamicSamplingContext = getDynamicSamplingContextFromScope(this, currentScope);\n\n      evt.sdkProcessingMetadata = {\n        dynamicSamplingContext,\n        ...evt.sdkProcessingMetadata,\n      };\n\n      return evt;\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 (DEBUG_BUILD) {\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 currentScope 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, currentScope) {\n    const options = this.getOptions();\n    const { sampleRate } = options;\n\n    const isTransaction = isTransactionEvent(event);\n    const isError = isErrorEvent(event);\n    const eventType = event.type || 'error';\n    const beforeSendLabel = `before send for type \\`${eventType}\\``;\n\n    // 1.0 === 100% events are sent\n    // 0.0 === 0% events are sent\n    // Sampling for transaction happens somewhere else\n    const parsedSampleRate = typeof sampleRate === 'undefined' ? undefined : parseSampleRate(sampleRate);\n    if (isError && typeof parsedSampleRate === 'number' && Math.random() > parsedSampleRate) {\n      this.recordDroppedEvent('sample_rate', 'error', event);\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    const dataCategory = eventType === 'replay_event' ? 'replay' : eventType;\n\n    const sdkProcessingMetadata = event.sdkProcessingMetadata || {};\n    const capturedSpanIsolationScope = sdkProcessingMetadata.capturedSpanIsolationScope;\n\n    return this._prepareEvent(event, hint, currentScope, capturedSpanIsolationScope)\n      .then(prepared => {\n        if (prepared === null) {\n          this.recordDroppedEvent('event_processor', dataCategory, event);\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) {\n          return prepared;\n        }\n\n        const result = processBeforeSend(this, options, prepared, hint);\n        return _validateBeforeSendResult(result, beforeSendLabel);\n      })\n      .then(processedEvent => {\n        if (processedEvent === null) {\n          this.recordDroppedEvent('before_send', dataCategory, event);\n          if (isTransaction) {\n            const spans = event.spans || [];\n            // the transaction itself counts as one span, plus all the child spans that are added\n            const spanCount = 1 + spans.length;\n            this.recordDroppedEvent('before_send', 'span', spanCount);\n          }\n          throw new SentryError(`${beforeSendLabel} returned \\`null\\`, will not send event.`, 'log');\n        }\n\n        const session = currentScope && currentScope.getSession();\n        if (!isTransaction && session) {\n          this._updateSessionFromEvent(session, processedEvent);\n        }\n\n        if (isTransaction) {\n          const spanCountBefore =\n            (processedEvent.sdkProcessingMetadata && processedEvent.sdkProcessingMetadata.spanCountBeforeProcessing) ||\n            0;\n          const spanCountAfter = processedEvent.spans ? processedEvent.spans.length : 0;\n\n          const droppedSpanCount = spanCountBefore - spanCountAfter;\n          if (droppedSpanCount > 0) {\n            this.recordDroppedEvent('before_send', 'span', droppedSpanCount);\n          }\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          };\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++;\n    void promise.then(\n      value => {\n        this._numProcessing--;\n        return value;\n      },\n      reason => {\n        this._numProcessing--;\n        return reason;\n      },\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.entries(outcomes).map(([key, quantity]) => {\n      const [reason, category] = key.split(':') ;\n      return {\n        reason,\n        category,\n        quantity,\n      };\n    });\n  }\n\n  /**\n   * Sends client reports as an envelope.\n   */\n   _flushOutcomes() {\n    DEBUG_BUILD && logger.log('Flushing outcomes...');\n\n    const outcomes = this._clearOutcomes();\n\n    if (outcomes.length === 0) {\n      DEBUG_BUILD && logger.log('No outcomes to send');\n      return;\n    }\n\n    // This is really the only place where we want to check for a DSN and only send outcomes then\n    if (!this._dsn) {\n      DEBUG_BUILD && logger.log('No dsn provided, will not send outcomes');\n      return;\n    }\n\n    DEBUG_BUILD && logger.log('Sending outcomes:', outcomes);\n\n    const envelope = createClientReportEnvelope(outcomes, this._options.tunnel && dsnToString(this._dsn));\n\n    // sendEnvelope should not throw\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.sendEnvelope(envelope);\n  }\n\n  /**\n   * @inheritDoc\n   */\n\n}\n\n/**\n * Verifies that return value of configured `beforeSend` or `beforeSendTransaction` is of expected type, and returns the value if so.\n */\nfunction _validateBeforeSendResult(\n  beforeSendResult,\n  beforeSendLabel,\n) {\n  const invalidValueError = `${beforeSendLabel} must return \\`null\\` or a valid event.`;\n  if (isThenable(beforeSendResult)) {\n    return beforeSendResult.then(\n      event => {\n        if (!isPlainObject(event) && event !== null) {\n          throw new SentryError(invalidValueError);\n        }\n        return event;\n      },\n      e => {\n        throw new SentryError(`${beforeSendLabel} rejected with ${e}`);\n      },\n    );\n  } else if (!isPlainObject(beforeSendResult) && beforeSendResult !== null) {\n    throw new SentryError(invalidValueError);\n  }\n  return beforeSendResult;\n}\n\n/**\n * Process the matching `beforeSendXXX` callback.\n */\nfunction processBeforeSend(\n  client,\n  options,\n  event,\n  hint,\n) {\n  const { beforeSend, beforeSendTransaction, beforeSendSpan } = options;\n\n  if (isErrorEvent(event) && beforeSend) {\n    return beforeSend(event, hint);\n  }\n\n  if (isTransactionEvent(event)) {\n    if (event.spans && beforeSendSpan) {\n      const processedSpans = [];\n      for (const span of event.spans) {\n        const processedSpan = beforeSendSpan(span);\n        if (processedSpan) {\n          processedSpans.push(processedSpan);\n        } else {\n          showSpanDropWarning();\n          client.recordDroppedEvent('before_send', 'span');\n        }\n      }\n      event.spans = processedSpans;\n    }\n\n    if (beforeSendTransaction) {\n      if (event.spans) {\n        // We store the # of spans before processing in SDK metadata,\n        // so we can compare it afterwards to determine how many spans were dropped\n        const spanCountBefore = event.spans.length;\n        event.sdkProcessingMetadata = {\n          ...event.sdkProcessingMetadata,\n          spanCountBeforeProcessing: spanCountBefore,\n        };\n      }\n      return beforeSendTransaction(event, hint);\n    }\n  }\n\n  return event;\n}\n\nfunction isErrorEvent(event) {\n  return event.type === undefined;\n}\n\nfunction isTransactionEvent(event) {\n  return event.type === 'transaction';\n}\n\nexport { BaseClient };\n//# sourceMappingURL=baseclient.js.map\n","import { getClient, getIsolationScope } from './currentScopes.js';\nimport { consoleSandbox } from './utils-hoist/logger.js';\nimport { dateTimestampInSeconds } from './utils-hoist/time.js';\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 * 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 */\nfunction addBreadcrumb(breadcrumb, hint) {\n  const client = getClient();\n  const isolationScope = getIsolationScope();\n\n  if (!client) return;\n\n  const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } = client.getOptions();\n\n  if (maxBreadcrumbs <= 0) return;\n\n  const timestamp = dateTimestampInSeconds();\n  const mergedBreadcrumb = { timestamp, ...breadcrumb };\n  const finalBreadcrumb = beforeBreadcrumb\n    ? (consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) )\n    : mergedBreadcrumb;\n\n  if (finalBreadcrumb === null) return;\n\n  if (client.emit) {\n    client.emit('beforeAddBreadcrumb', finalBreadcrumb, hint);\n  }\n\n  isolationScope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);\n}\n\nexport { addBreadcrumb };\n//# sourceMappingURL=breadcrumbs.js.map\n","import { SDK_VERSION } from './utils-hoist/version.js';\nimport { GLOBAL_OBJ } from './utils-hoist/worldwide.js';\n\n/**\n * An object that contains globally accessible properties and maintains a scope stack.\n * @hidden\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  // This ensures a Sentry carrier exists\n  getSentryCarrier(GLOBAL_OBJ);\n  return GLOBAL_OBJ;\n}\n\n/** Will either get the existing sentry carrier, or create a new one. */\nfunction getSentryCarrier(carrier) {\n  const __SENTRY__ = (carrier.__SENTRY__ = carrier.__SENTRY__ || {});\n\n  // For now: First SDK that sets the .version property wins\n  __SENTRY__.version = __SENTRY__.version || SDK_VERSION;\n\n  // Intentionally populating and returning the version of \"this\" SDK instance\n  // rather than what's set in .version so that \"this\" SDK always gets its carrier\n  return (__SENTRY__[SDK_VERSION] = __SENTRY__[SDK_VERSION] || {});\n}\n\nexport { getMainCarrier, getSentryCarrier };\n//# sourceMappingURL=carrier.js.map\n","const DEFAULT_ENVIRONMENT = 'production';\n\nexport { DEFAULT_ENVIRONMENT };\n//# sourceMappingURL=constants.js.map\n","import { getAsyncContextStrategy } from './asyncContext/index.js';\nimport { getMainCarrier } from './carrier.js';\nimport { Scope } from './scope.js';\nimport { dropUndefinedKeys } from './utils-hoist/object.js';\nimport { getGlobalSingleton } from './utils-hoist/worldwide.js';\n\n/**\n * Get the currently active scope.\n */\nfunction getCurrentScope() {\n  const carrier = getMainCarrier();\n  const acs = getAsyncContextStrategy(carrier);\n  return acs.getCurrentScope();\n}\n\n/**\n * Get the currently active isolation scope.\n * The isolation scope is active for the current execution context.\n */\nfunction getIsolationScope() {\n  const carrier = getMainCarrier();\n  const acs = getAsyncContextStrategy(carrier);\n  return acs.getIsolationScope();\n}\n\n/**\n * Get the global scope.\n * This scope is applied to _all_ events.\n */\nfunction getGlobalScope() {\n  return getGlobalSingleton('globalScope', () => new Scope());\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\n/**\n * Either creates a new active scope, or sets the given scope as active scope in the given callback.\n */\nfunction withScope(\n  ...rest\n) {\n  const carrier = getMainCarrier();\n  const acs = getAsyncContextStrategy(carrier);\n\n  // If a scope is defined, we want to make this the active scope instead of the default one\n  if (rest.length === 2) {\n    const [scope, callback] = rest;\n\n    if (!scope) {\n      return acs.withScope(callback);\n    }\n\n    return acs.withSetScope(scope, callback);\n  }\n\n  return acs.withScope(rest[0]);\n}\n\n/**\n * Attempts to fork the current isolation scope and the current scope based on the current async context strategy. If no\n * async context strategy is set, the isolation scope and the current scope will not be forked (this is currently the\n * case, for example, in the browser).\n *\n * Usage of this function in environments without async context strategy is discouraged and may lead to unexpected behaviour.\n *\n * This function is intended for Sentry SDK and SDK integration development. It is not recommended to be used in \"normal\"\n * applications directly because it comes with pitfalls. Use at your own risk!\n */\n\n/**\n * Either creates a new active isolation scope, or sets the given isolation scope as active scope in the given callback.\n */\nfunction withIsolationScope(\n  ...rest\n\n) {\n  const carrier = getMainCarrier();\n  const acs = getAsyncContextStrategy(carrier);\n\n  // If a scope is defined, we want to make this the active scope instead of the default one\n  if (rest.length === 2) {\n    const [isolationScope, callback] = rest;\n\n    if (!isolationScope) {\n      return acs.withIsolationScope(callback);\n    }\n\n    return acs.withSetIsolationScope(isolationScope, callback);\n  }\n\n  return acs.withIsolationScope(rest[0]);\n}\n\n/**\n * Get the currently active client.\n */\nfunction getClient() {\n  return getCurrentScope().getClient();\n}\n\n/**\n * Get a trace context for the given scope.\n */\nfunction getTraceContextFromScope(scope) {\n  const propagationContext = scope.getPropagationContext();\n\n  // TODO(v9): Use generateSpanId() instead of spanId\n  // eslint-disable-next-line deprecation/deprecation\n  const { traceId, spanId, parentSpanId } = propagationContext;\n\n  const traceContext = dropUndefinedKeys({\n    trace_id: traceId,\n    span_id: spanId,\n    parent_span_id: parentSpanId,\n  });\n\n  return traceContext;\n}\n\nexport { getClient, getCurrentScope, getGlobalScope, getIsolationScope, getTraceContextFromScope, withIsolationScope, withScope };\n//# sourceMappingURL=currentScopes.js.map\n","/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nconst DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);\n\nexport { DEBUG_BUILD };\n//# sourceMappingURL=debug-build.js.map\n","import { getDynamicSamplingContextFromSpan } from './tracing/dynamicSamplingContext.js';\nimport { dsnToString } from './utils-hoist/dsn.js';\nimport { getSdkMetadataForEnvelopeHeader, createEnvelope, createEventEnvelopeHeaders, createSpanEnvelopeItem } from './utils-hoist/envelope.js';\nimport './utils-hoist/version.js';\nimport './utils-hoist/debug-build.js';\nimport './utils-hoist/logger.js';\nimport { spanToJSON, showSpanDropWarning } from './utils/spanUtils.js';\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 && { dsn: dsnToString(dsn) }),\n  };\n\n  const envelopeItem =\n    'aggregates' in session ? [{ type: 'sessions' }, session] : [{ type: 'session' }, session.toJSON()];\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\n  /*\n    Note: Due to TS, event.type may be `replay_event`, theoretically.\n    In practice, we never call `createEventEnvelope` with `replay_event` type,\n    and we'd have to adjust a looot of types to make this work properly.\n    We want to avoid casting this around, as that could lead to bugs (e.g. when we add another type)\n    So the safe choice is to really guard against the replay_event type here.\n  */\n  const eventType = event.type && event.type !== 'replay_event' ? 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\n/**\n * Create envelope from Span item.\n *\n * Takes an optional client and runs spans through `beforeSendSpan` if available.\n */\nfunction createSpanEnvelope(spans, client) {\n  function dscHasRequiredProps(dsc) {\n    return !!dsc.trace_id && !!dsc.public_key;\n  }\n\n  // For the moment we'll obtain the DSC from the first span in the array\n  // This might need to be changed if we permit sending multiple spans from\n  // different segments in one envelope\n  const dsc = getDynamicSamplingContextFromSpan(spans[0]);\n\n  const dsn = client && client.getDsn();\n  const tunnel = client && client.getOptions().tunnel;\n\n  const headers = {\n    sent_at: new Date().toISOString(),\n    ...(dscHasRequiredProps(dsc) && { trace: dsc }),\n    ...(!!tunnel && dsn && { dsn: dsnToString(dsn) }),\n  };\n\n  const beforeSendSpan = client && client.getOptions().beforeSendSpan;\n  const convertToSpanJSON = beforeSendSpan\n    ? (span) => {\n        const spanJson = beforeSendSpan(spanToJSON(span) );\n        if (!spanJson) {\n          showSpanDropWarning();\n        }\n        return spanJson;\n      }\n    : (span) => spanToJSON(span);\n\n  const items = [];\n  for (const span of spans) {\n    const spanJson = convertToSpanJSON(span);\n    if (spanJson) {\n      items.push(createSpanEnvelopeItem(spanJson));\n    }\n  }\n\n  return createEnvelope(headers, items);\n}\n\nexport { createEventEnvelope, createSessionEnvelope, createSpanEnvelope };\n//# sourceMappingURL=envelope.js.map\n","import { DEBUG_BUILD } from './debug-build.js';\nimport { isThenable } from './utils-hoist/is.js';\nimport { logger } from './utils-hoist/logger.js';\nimport { SyncPromise } from './utils-hoist/syncpromise.js';\n\n/**\n * Process an array of event processors, returning the processed event (or `null` if the event was dropped).\n */\nfunction notifyEventProcessors(\n  processors,\n  event,\n  hint,\n  index = 0,\n) {\n  return new SyncPromise((resolve, reject) => {\n    const processor = processors[index];\n    if (event === null || typeof processor !== 'function') {\n      resolve(event);\n    } else {\n      const result = processor({ ...event }, hint) ;\n\n      DEBUG_BUILD && processor.id && result === null && logger.log(`Event processor \"${processor.id}\" dropped event`);\n\n      if (isThenable(result)) {\n        void result\n          .then(final => notifyEventProcessors(processors, final, hint, index + 1).then(resolve))\n          .then(null, reject);\n      } else {\n        void notifyEventProcessors(processors, result, hint, index + 1)\n          .then(resolve)\n          .then(null, reject);\n      }\n    }\n  });\n}\n\nexport { notifyEventProcessors };\n//# sourceMappingURL=eventProcessors.js.map\n","import { DEFAULT_ENVIRONMENT } from './constants.js';\nimport { getCurrentScope, getIsolationScope, getClient, withIsolationScope } from './currentScopes.js';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { makeSession, updateSession, closeSession } from './session.js';\nimport { isThenable } from './utils-hoist/is.js';\nimport { logger } from './utils-hoist/logger.js';\nimport { uuid4 } from './utils-hoist/misc.js';\nimport { timestampInSeconds } from './utils-hoist/time.js';\nimport { GLOBAL_OBJ } from './utils-hoist/worldwide.js';\nimport { parseEventHintOrCaptureContext } from './utils/prepareEvent.js';\n\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception The exception to capture.\n * @param hint Optional additional data to attach to the Sentry event.\n * @returns the id of the captured Sentry event.\n */\nfunction captureException(exception, hint) {\n  return getCurrentScope().captureException(exception, parseEventHintOrCaptureContext(hint));\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 captureContext Define the level of the message or pass in additional data to attach to the message.\n * @returns the id of the captured message.\n */\nfunction captureMessage(message, captureContext) {\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 getCurrentScope().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 * @param hint Optional additional data to attach to the Sentry event.\n * @returns the id of the captured event.\n */\nfunction captureEvent(event, hint) {\n  return getCurrentScope().captureEvent(event, hint);\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 */\nfunction setContext(name, context) {\n  getIsolationScope().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  getIsolationScope().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  getIsolationScope().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  getIsolationScope().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  getIsolationScope().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  getIsolationScope().setUser(user);\n}\n\n/**\n * The last error event id of the isolation scope.\n *\n * Warning: This function really returns the last recorded error event id on the current\n * isolation scope. If you call this function after handling a certain error and another error\n * is captured in between, the last one is returned instead of the one you might expect.\n * Also, ids of events that were never sent to Sentry (for example because\n * they were dropped in `beforeSend`) could be returned.\n *\n * @returns The last event id of the isolation scope.\n */\nfunction lastEventId() {\n  return getIsolationScope().lastEventId();\n}\n\n/**\n * Create a cron monitor check in and send it to Sentry.\n *\n * @param checkIn An object that describes a check in.\n * @param upsertMonitorConfig An optional object that describes a monitor config. Use this if you want\n * to create a monitor automatically when sending a check in.\n */\nfunction captureCheckIn(checkIn, upsertMonitorConfig) {\n  const scope = getCurrentScope();\n  const client = getClient();\n  if (!client) {\n    DEBUG_BUILD && logger.warn('Cannot capture check-in. No client defined.');\n  } else if (!client.captureCheckIn) {\n    DEBUG_BUILD && logger.warn('Cannot capture check-in. Client does not support sending check-ins.');\n  } else {\n    return client.captureCheckIn(checkIn, upsertMonitorConfig, scope);\n  }\n\n  return uuid4();\n}\n\n/**\n * Wraps a callback with a cron monitor check in. The check in will be sent to Sentry when the callback finishes.\n *\n * @param monitorSlug The distinct slug of the monitor.\n * @param upsertMonitorConfig An optional object that describes a monitor config. Use this if you want\n * to create a monitor automatically when sending a check in.\n */\nfunction withMonitor(\n  monitorSlug,\n  callback,\n  upsertMonitorConfig,\n) {\n  const checkInId = captureCheckIn({ monitorSlug, status: 'in_progress' }, upsertMonitorConfig);\n  const now = timestampInSeconds();\n\n  function finishCheckIn(status) {\n    captureCheckIn({ monitorSlug, status, checkInId, duration: timestampInSeconds() - now });\n  }\n\n  return withIsolationScope(() => {\n    let maybePromiseResult;\n    try {\n      maybePromiseResult = callback();\n    } catch (e) {\n      finishCheckIn('error');\n      throw e;\n    }\n\n    if (isThenable(maybePromiseResult)) {\n      Promise.resolve(maybePromiseResult).then(\n        () => {\n          finishCheckIn('ok');\n        },\n        e => {\n          finishCheckIn('error');\n          throw e;\n        },\n      );\n    } else {\n      finishCheckIn('ok');\n    }\n\n    return maybePromiseResult;\n  });\n}\n\n/**\n * Call `flush()` on the current client, if there is one. See {@link Client.flush}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue. Omitting this parameter will cause\n * the client to wait until all events are sent before resolving the promise.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nasync function flush(timeout) {\n  const client = getClient();\n  if (client) {\n    return client.flush(timeout);\n  }\n  DEBUG_BUILD && logger.warn('Cannot flush events. No client defined.');\n  return Promise.resolve(false);\n}\n\n/**\n * Call `close()` on the current client, if there is one. See {@link Client.close}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue before shutting down. Omitting this\n * parameter will cause the client to wait until all events are sent before disabling itself.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nasync function close(timeout) {\n  const client = getClient();\n  if (client) {\n    return client.close(timeout);\n  }\n  DEBUG_BUILD && logger.warn('Cannot flush events and disable SDK. No client defined.');\n  return Promise.resolve(false);\n}\n\n/**\n * Returns true if Sentry has been properly initialized.\n */\nfunction isInitialized() {\n  return !!getClient();\n}\n\n/** If the SDK is initialized & enabled. */\nfunction isEnabled() {\n  const client = getClient();\n  return !!client && client.getOptions().enabled !== false && !!client.getTransport();\n}\n\n/**\n * Add an event processor.\n * This will be added to the current isolation scope, ensuring any event that is processed in the current execution\n * context will have the processor applied.\n */\nfunction addEventProcessor(callback) {\n  getIsolationScope().addEventProcessor(callback);\n}\n\n/**\n * Start a session on the current isolation scope.\n *\n * @param context (optional) additional properties to be applied to the returned session object\n *\n * @returns the new active session\n */\nfunction startSession(context) {\n  const client = getClient();\n  const isolationScope = getIsolationScope();\n  const currentScope = getCurrentScope();\n\n  const { release, environment = DEFAULT_ENVIRONMENT } = (client && client.getOptions()) || {};\n\n  // Will fetch userAgent if called from browser sdk\n  const { userAgent } = GLOBAL_OBJ.navigator || {};\n\n  const session = makeSession({\n    release,\n    environment,\n    user: currentScope.getUser() || isolationScope.getUser(),\n    ...(userAgent && { userAgent }),\n    ...context,\n  });\n\n  // End existing session if there's one\n  const currentSession = isolationScope.getSession();\n  if (currentSession && currentSession.status === 'ok') {\n    updateSession(currentSession, { status: 'exited' });\n  }\n\n  endSession();\n\n  // Afterwards we set the new session on the scope\n  isolationScope.setSession(session);\n\n  // TODO (v8): Remove this and only use the isolation scope(?).\n  // For v7 though, we can't \"soft-break\" people using getCurrentHub().getScope().setSession()\n  currentScope.setSession(session);\n\n  return session;\n}\n\n/**\n * End the session on the current isolation scope.\n */\nfunction endSession() {\n  const isolationScope = getIsolationScope();\n  const currentScope = getCurrentScope();\n\n  const session = currentScope.getSession() || isolationScope.getSession();\n  if (session) {\n    closeSession(session);\n  }\n  _sendSessionUpdate();\n\n  // the session is over; take it off of the scope\n  isolationScope.setSession();\n\n  // TODO (v8): Remove this and only use the isolation scope(?).\n  // For v7 though, we can't \"soft-break\" people using getCurrentHub().getScope().setSession()\n  currentScope.setSession();\n}\n\n/**\n * Sends the current Session on the scope\n */\nfunction _sendSessionUpdate() {\n  const isolationScope = getIsolationScope();\n  const currentScope = getCurrentScope();\n  const client = getClient();\n  // TODO (v8): Remove currentScope and only use the isolation scope(?).\n  // For v7 though, we can't \"soft-break\" people using getCurrentHub().getScope().setSession()\n  const session = currentScope.getSession() || isolationScope.getSession();\n  if (session && client) {\n    client.captureSession(session);\n  }\n}\n\n/**\n * Sends the current session on the scope to Sentry\n *\n * @param end If set the session will be marked as exited and removed from the scope.\n *            Defaults to `false`.\n */\nfunction captureSession(end = false) {\n  // both send the update and pull the session from the scope\n  if (end) {\n    endSession();\n    return;\n  }\n\n  // only send the update\n  _sendSessionUpdate();\n}\n\nexport { addEventProcessor, captureCheckIn, captureEvent, captureException, captureMessage, captureSession, close, endSession, flush, isEnabled, isInitialized, lastEventId, setContext, setExtra, setExtras, setTag, setTags, setUser, startSession, withMonitor };\n//# sourceMappingURL=exports.js.map\n","import { getClient, getCurrentScope } from './currentScopes.js';\nimport { dropUndefinedKeys } from './utils-hoist/object.js';\n\n/**\n * Send user feedback to Sentry.\n */\nfunction captureFeedback(\n  params,\n  hint = {},\n  scope = getCurrentScope(),\n) {\n  const { message, name, email, url, source, associatedEventId, tags } = params;\n\n  const feedbackEvent = {\n    contexts: {\n      feedback: dropUndefinedKeys({\n        contact_email: email,\n        name,\n        message,\n        url,\n        source,\n        associated_event_id: associatedEventId,\n      }),\n    },\n    type: 'feedback',\n    level: 'info',\n    tags,\n  };\n\n  const client = (scope && scope.getClient()) || getClient();\n\n  if (client) {\n    client.emit('beforeSendFeedback', feedbackEvent, hint);\n  }\n\n  const eventId = scope.captureEvent(feedbackEvent, hint);\n\n  return eventId;\n}\n\nexport { captureFeedback };\n//# sourceMappingURL=feedback.js.map\n","import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_OP } from './semanticAttributes.js';\nimport './tracing/errors.js';\nimport { isInstanceOf } from './utils-hoist/is.js';\nimport './utils-hoist/version.js';\nimport './utils-hoist/debug-build.js';\nimport './utils-hoist/logger.js';\nimport './utils-hoist/time.js';\nimport './utils-hoist/syncpromise.js';\nimport { parseUrl } from './utils-hoist/url.js';\nimport { SENTRY_BAGGAGE_KEY_PREFIX } from './utils-hoist/baggage.js';\nimport './debug-build.js';\nimport { hasTracingEnabled } from './utils/hasTracingEnabled.js';\nimport { getActiveSpan } from './utils/spanUtils.js';\nimport { SentryNonRecordingSpan } from './tracing/sentryNonRecordingSpan.js';\nimport { setHttpStatus, SPAN_STATUS_ERROR } from './tracing/spanstatus.js';\nimport { startInactiveSpan } from './tracing/trace.js';\nimport { getTraceData } from './utils/traceData.js';\n\n/**\n * Create and track fetch request spans for usage in combination with `addFetchInstrumentationHandler`.\n *\n * @returns Span if a span was created, otherwise void.\n */\nfunction instrumentFetchRequest(\n  handlerData,\n  shouldCreateSpan,\n  shouldAttachHeaders,\n  spans,\n  spanOrigin = 'auto.http.browser',\n) {\n  if (!handlerData.fetchData) {\n    return undefined;\n  }\n\n  const shouldCreateSpanResult = hasTracingEnabled() && shouldCreateSpan(handlerData.fetchData.url);\n\n  if (handlerData.endTimestamp && shouldCreateSpanResult) {\n    const spanId = handlerData.fetchData.__span;\n    if (!spanId) return;\n\n    const span = spans[spanId];\n    if (span) {\n      endSpan(span, handlerData);\n\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete spans[spanId];\n    }\n    return undefined;\n  }\n\n  const { method, url } = handlerData.fetchData;\n\n  const fullUrl = getFullURL(url);\n  const host = fullUrl ? parseUrl(fullUrl).host : undefined;\n\n  const hasParent = !!getActiveSpan();\n\n  const span =\n    shouldCreateSpanResult && hasParent\n      ? startInactiveSpan({\n          name: `${method} ${url}`,\n          attributes: {\n            url,\n            type: 'fetch',\n            'http.method': method,\n            'http.url': fullUrl,\n            'server.address': host,\n            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: spanOrigin,\n            [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.client',\n          },\n        })\n      : new SentryNonRecordingSpan();\n\n  handlerData.fetchData.__span = span.spanContext().spanId;\n  spans[span.spanContext().spanId] = span;\n\n  if (shouldAttachHeaders(handlerData.fetchData.url)) {\n    const request = handlerData.args[0];\n\n    const options = handlerData.args[1] || {};\n\n    const headers = _addTracingHeadersToFetchRequest(\n      request,\n      options,\n      // If performance is disabled (TWP) or there's no active root span (pageload/navigation/interaction),\n      // we do not want to use the span as base for the trace headers,\n      // which means that the headers will be generated from the scope and the sampling decision is deferred\n      hasTracingEnabled() && hasParent ? span : undefined,\n    );\n    if (headers) {\n      // Ensure this is actually set, if no options have been passed previously\n      handlerData.args[1] = options;\n      options.headers = headers;\n    }\n  }\n\n  return span;\n}\n\n/**\n * Adds sentry-trace and baggage headers to the various forms of fetch headers.\n */\nfunction _addTracingHeadersToFetchRequest(\n  request,\n  fetchOptionsObj\n\n,\n  span,\n) {\n  const traceHeaders = getTraceData({ span });\n  const sentryTrace = traceHeaders['sentry-trace'];\n  const baggage = traceHeaders.baggage;\n\n  // Nothing to do, when we return undefined here, the original headers will be used\n  if (!sentryTrace) {\n    return undefined;\n  }\n\n  const headers = fetchOptionsObj.headers || (isRequest(request) ? request.headers : undefined);\n\n  if (!headers) {\n    return { ...traceHeaders };\n  } else if (isHeaders(headers)) {\n    const newHeaders = new Headers(headers);\n    newHeaders.set('sentry-trace', sentryTrace);\n\n    if (baggage) {\n      const prevBaggageHeader = newHeaders.get('baggage');\n      if (prevBaggageHeader) {\n        const prevHeaderStrippedFromSentryBaggage = stripBaggageHeaderOfSentryBaggageValues(prevBaggageHeader);\n        newHeaders.set(\n          'baggage',\n          // If there are non-sentry entries (i.e. if the stripped string is non-empty/truthy) combine the stripped header and sentry baggage header\n          // otherwise just set the sentry baggage header\n          prevHeaderStrippedFromSentryBaggage ? `${prevHeaderStrippedFromSentryBaggage},${baggage}` : baggage,\n        );\n      } else {\n        newHeaders.set('baggage', baggage);\n      }\n    }\n\n    return newHeaders;\n  } else if (Array.isArray(headers)) {\n    const newHeaders = [\n      ...headers\n        // Remove any existing sentry-trace headers\n        .filter(header => {\n          return !(Array.isArray(header) && header[0] === 'sentry-trace');\n        })\n        // Get rid of previous sentry baggage values in baggage header\n        .map(header => {\n          if (Array.isArray(header) && header[0] === 'baggage' && typeof header[1] === 'string') {\n            const [headerName, headerValue, ...rest] = header;\n            return [headerName, stripBaggageHeaderOfSentryBaggageValues(headerValue), ...rest];\n          } else {\n            return header;\n          }\n        }),\n      // Attach the new sentry-trace header\n      ['sentry-trace', sentryTrace],\n    ];\n\n    if (baggage) {\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', baggage]);\n    }\n\n    return newHeaders ;\n  } else {\n    const existingBaggageHeader = 'baggage' in headers ? headers.baggage : undefined;\n    let newBaggageHeaders = [];\n\n    if (Array.isArray(existingBaggageHeader)) {\n      newBaggageHeaders = existingBaggageHeader\n        .map(headerItem =>\n          typeof headerItem === 'string' ? stripBaggageHeaderOfSentryBaggageValues(headerItem) : headerItem,\n        )\n        .filter(headerItem => headerItem === '');\n    } else if (existingBaggageHeader) {\n      newBaggageHeaders.push(stripBaggageHeaderOfSentryBaggageValues(existingBaggageHeader));\n    }\n\n    if (baggage) {\n      newBaggageHeaders.push(baggage);\n    }\n\n    return {\n      ...(headers ),\n      'sentry-trace': sentryTrace,\n      baggage: newBaggageHeaders.length > 0 ? newBaggageHeaders.join(',') : undefined,\n    };\n  }\n}\n\n/**\n * Adds sentry-trace and baggage headers to the various forms of fetch headers.\n *\n * @deprecated This function will not be exported anymore in v9.\n */\nfunction addTracingHeadersToFetchRequest(\n  request,\n  _client,\n  _scope,\n  fetchOptionsObj\n\n,\n  span,\n) {\n  return _addTracingHeadersToFetchRequest(request , fetchOptionsObj, span);\n}\n\nfunction getFullURL(url) {\n  try {\n    const parsed = new URL(url);\n    return parsed.href;\n  } catch (e) {\n    return undefined;\n  }\n}\n\nfunction endSpan(span, handlerData) {\n  if (handlerData.response) {\n    setHttpStatus(span, handlerData.response.status);\n\n    const contentLength =\n      handlerData.response && handlerData.response.headers && handlerData.response.headers.get('content-length');\n\n    if (contentLength) {\n      const contentLengthNum = parseInt(contentLength);\n      if (contentLengthNum > 0) {\n        span.setAttribute('http.response_content_length', contentLengthNum);\n      }\n    }\n  } else if (handlerData.error) {\n    span.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_error' });\n  }\n  span.end();\n}\n\nfunction stripBaggageHeaderOfSentryBaggageValues(baggageHeader) {\n  return (\n    baggageHeader\n      .split(',')\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      .filter(baggageEntry => !baggageEntry.split('=')[0].startsWith(SENTRY_BAGGAGE_KEY_PREFIX))\n      .join(',')\n  );\n}\n\nfunction isRequest(request) {\n  return typeof Request !== 'undefined' && isInstanceOf(request, Request);\n}\n\nfunction isHeaders(headers) {\n  return typeof Headers !== 'undefined' && isInstanceOf(headers, Headers);\n}\n\nexport { addTracingHeadersToFetchRequest, instrumentFetchRequest };\n//# sourceMappingURL=fetch.js.map\n"],"names":["SENTRY_API_VERSION","getBaseApiEndpoint","dsn","protocol","port","host","path","getEnvelopeEndpointWithUrlEncodedAuth","tunnel","sdkInfo","projectId","_getIngestEndpoint","params","sentry_version","publicKey","sentry_key","sentry_client","name","version","URLSearchParams","toString","_encodedAuth","getReportDialogEndpoint","dsnLike","dialogOptions","endpoint","encodedOptions","key","user","encodeURIComponent","email","AsyncContextStack","constructor","scope","isolationScope","assignedScope","assignedIsolationScope","this","_stack","_isolationScope","withScope","callback","_pushScope","maybePromiseResult","e","_popScope","is","then","res","getClient","getStackTop","client","getScope","getIsolationScope","length","clone","push","pop","getAsyncContextStack","registry","sentry","stack","withSetScope","withIsolationScope","getAsyncContextStrategy","carrier","acs","withSetIsolationScope","getCurrentScope","ALREADY_SEEN_ERROR","BaseClient","options","_options","_integrations","_numProcessing","_outcomes","_hooks","_eventProcessors","_dsn","warn","url","_metadata","sdk","undefined","_transport","transport","recordDroppedEvent","bind","transportOptions","undefinedOption","find","option","console","captureException","exception","hint","eventId","log","hintWithEventId","event_id","_process","eventFromException","event","_captureEvent","captureMessage","message","level","currentScope","eventMessage","String","promisedEvent","eventFromMessage","captureEvent","originalException","capturedSpanScope","sdkProcessingMetadata","captureSession","session","release","sendSession","init","getDsn","getOptions","getSdkMetadata","getTransport","flush","timeout","emit","_isClientDoneProcessing","clientFinished","transportFlushed","close","result","enabled","getEventProcessors","addEventProcessor","eventProcessor","_isEnabled","integrations","some","startsWith","_setupIntegrations","getIntegrationByName","integrationName","addIntegration","integration","isAlreadyInstalled","sendEvent","env","attachment","attachments","promise","sendEnvelope","sendResponse","reason","category","eventOrCount","sendClientReports","count","on","hook","hooks","cbIndex","indexOf","splice","rest","callbacks","forEach","envelope","send","error","_updateSessionFromEvent","crashed","errored","exceptions","values","ex","mechanism","handled","sessionNonTerminal","status","errors","Number","resolve","ticked","interval","setInterval","clearInterval","_prepareEvent","Object","keys","type","setLastEventId","evt","contexts","trace","dynamicSamplingContext","_processEvent","finalEvent","sentryError","logLevel","sampleRate","isTransaction","isTransactionEvent","isError","isErrorEvent","eventType","beforeSendLabel","parsedSampleRate","Math","random","dataCategory","capturedSpanIsolationScope","prepared","data","__sentry__","beforeSend","beforeSendTransaction","beforeSendSpan","spans","processedSpans","span","processedSpan","spanCountBefore","spanCountBeforeProcessing","processBeforeSend","beforeSendResult","invalidValueError","_validateBeforeSendResult","processedEvent","spanCount","getSession","droppedSpanCount","transactionInfo","transaction_info","transaction","source","value","_clearOutcomes","outcomes","entries","map","quantity","split","_flushOutcomes","DEFAULT_BREADCRUMBS","addBreadcrumb","breadcrumb","beforeBreadcrumb","maxBreadcrumbs","mergedBreadcrumb","timestamp","finalBreadcrumb","getMainCarrier","getSentryCarrier","__SENTRY__","DEFAULT_ENVIRONMENT","getGlobalScope","getTraceContextFromScope","propagationContext","getPropagationContext","traceId","spanId","parentSpanId","trace_id","span_id","parent_span_id","DEBUG_BUILD","__SENTRY_DEBUG__","createSessionEnvelope","metadata","envelopeHeaders","sent_at","Date","toISOString","envelopeItem","toJSON","createEventEnvelope","packages","enhanceEventWithSdkInfo","eventItem","createSpanEnvelope","dsc","headers","public_key","dscHasRequiredProps","convertToSpanJSON","spanJson","items","notifyEventProcessors","processors","index","reject","processor","id","final","captureContext","context","setContext","setExtras","extras","setExtra","extra","setTags","tags","setTag","setUser","lastEventId","async","Promise","isInitialized","isEnabled","startSession","environment","userAgent","navigator","getUser","currentSession","endSession","setSession","_sendSessionUpdate","end","captureFeedback","associatedEventId","feedbackEvent","feedback","contact_email","associated_event_id","instrumentFetchRequest","handlerData","shouldCreateSpan","shouldAttachHeaders","spanOrigin","fetchData","shouldCreateSpanResult","endTimestamp","__span","response","contentLength","get","contentLengthNum","parseInt","setAttribute","setStatus","code","endSpan","method","fullUrl","URL","href","getFullURL","hasParent","attributes","spanContext","request","args","_addTracingHeadersToFetchRequest","fetchOptionsObj","traceHeaders","sentryTrace","baggage","Request","isRequest","Headers","isHeaders","newHeaders","set","prevBaggageHeader","prevHeaderStrippedFromSentryBaggage","stripBaggageHeaderOfSentryBaggageValues","Array","isArray","filter","header","headerName","headerValue","existingBaggageHeader","newBaggageHeaders","headerItem","join","baggageHeader","baggageEntry"],"sourceRoot":""}