{"version":3,"file":"js/7510-f71d0cef3b3a8509cb09.js","mappings":"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","sources":["webpack://artfully-walls/./node_modules/@sentry/core/build/esm/tracing/dynamicSamplingContext.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/tracing/errors.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/tracing/hubextensions.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/tracing/idleSpan.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/tracing/measurement.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/tracing/sentryNonRecordingSpan.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/tracing/spanstatus.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/tracing/utils.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/tracing/sentrySpan.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/tracing/logSpans.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/tracing/trace.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/tracing/sampling.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/promisebuffer.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/transports/base.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/transports/multiplexed.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/transports/offline.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/aggregate-errors.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/baggage.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/breadcrumb-log-level.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/browser.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/buildPolyfills/_nullishCoalesce.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/buildPolyfills/_optionalChain.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/clientreport.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/debug-build.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/debug-ids.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/dsn.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/env.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/envelope.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/error.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/instrument/console.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/instrument/fetch.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/instrument/globalError.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/instrument/globalUnhandledRejection.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/instrument/handlers.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/is.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/isBrowser.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/node.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/logger.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/misc.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/normalize.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/memo.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/object.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/path.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/propagationContext.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/ratelimit.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/severity.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/stacktrace.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/string.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/supports.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/syncpromise.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/time.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/tracing.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/url.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/vendor/supportsHistory.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/version.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils-hoist/worldwide.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils/handleCallbackErrors.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils/hasTracingEnabled.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils/isSentryRequestUrl.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils/merge.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils/parameterize.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils/parseSampleRate.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils/applyScopeDataToEvent.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils/prepareEvent.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils/sdkMetadata.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils/spanOnScope.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils/spanUtils.js","webpack://artfully-walls/./node_modules/@sentry/core/build/esm/utils/traceData.js"],"sourcesContent":["import { DEFAULT_ENVIRONMENT } from '../constants.js';\nimport { getClient } from '../currentScopes.js';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '../semanticAttributes.js';\nimport { baggageHeaderToDynamicSamplingContext, dynamicSamplingContextToSentryBaggageHeader } from '../utils-hoist/baggage.js';\nimport { dropUndefinedKeys, addNonEnumerableProperty } from '../utils-hoist/object.js';\nimport { hasTracingEnabled } from '../utils/hasTracingEnabled.js';\nimport { getRootSpan, spanToJSON, spanIsSampled } from '../utils/spanUtils.js';\n\n/**\n * If you change this value, also update the terser plugin config to\n * avoid minification of the object property!\n */\nconst FROZEN_DSC_FIELD = '_frozenDsc';\n\n/**\n * Freeze the given DSC on the given span.\n */\nfunction freezeDscOnSpan(span, dsc) {\n  const spanWithMaybeDsc = span ;\n  addNonEnumerableProperty(spanWithMaybeDsc, FROZEN_DSC_FIELD, dsc);\n}\n\n/**\n * Creates a dynamic sampling context from a client.\n *\n * Dispatches the `createDsc` lifecycle hook as a side effect.\n */\nfunction getDynamicSamplingContextFromClient(trace_id, client) {\n  const options = client.getOptions();\n\n  const { publicKey: public_key } = client.getDsn() || {};\n\n  const dsc = dropUndefinedKeys({\n    environment: options.environment || DEFAULT_ENVIRONMENT,\n    release: options.release,\n    public_key,\n    trace_id,\n  }) ;\n\n  client.emit('createDsc', dsc);\n\n  return dsc;\n}\n\n/**\n * Get the dynamic sampling context for the currently active scopes.\n */\nfunction getDynamicSamplingContextFromScope(client, scope) {\n  const propagationContext = scope.getPropagationContext();\n  return propagationContext.dsc || getDynamicSamplingContextFromClient(propagationContext.traceId, client);\n}\n\n/**\n * Creates a dynamic sampling context from a span (and client and scope)\n *\n * @param span the span from which a few values like the root span name and sample rate are extracted.\n *\n * @returns a dynamic sampling context\n */\nfunction getDynamicSamplingContextFromSpan(span) {\n  const client = getClient();\n  if (!client) {\n    return {};\n  }\n\n  const rootSpan = getRootSpan(span);\n\n  // For core implementation, we freeze the DSC onto the span as a non-enumerable property\n  const frozenDsc = (rootSpan )[FROZEN_DSC_FIELD];\n  if (frozenDsc) {\n    return frozenDsc;\n  }\n\n  // For OpenTelemetry, we freeze the DSC on the trace state\n  const traceState = rootSpan.spanContext().traceState;\n  const traceStateDsc = traceState && traceState.get('sentry.dsc');\n\n  // If the span has a DSC, we want it to take precedence\n  const dscOnTraceState = traceStateDsc && baggageHeaderToDynamicSamplingContext(traceStateDsc);\n\n  if (dscOnTraceState) {\n    return dscOnTraceState;\n  }\n\n  // Else, we generate it from the span\n  const dsc = getDynamicSamplingContextFromClient(span.spanContext().traceId, client);\n  const jsonSpan = spanToJSON(rootSpan);\n  const attributes = jsonSpan.data || {};\n  const maybeSampleRate = attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE];\n\n  if (maybeSampleRate != null) {\n    dsc.sample_rate = `${maybeSampleRate}`;\n  }\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 source = attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];\n\n  // after JSON conversion, txn.name becomes jsonSpan.description\n  const name = jsonSpan.description;\n  if (source !== 'url' && name) {\n    dsc.transaction = name;\n  }\n\n  // How can we even land here with hasTracingEnabled() returning false?\n  // Otel creates a Non-recording span in Tracing Without Performance mode when handling incoming requests\n  // So we end up with an active span that is not sampled (neither positively nor negatively)\n  if (hasTracingEnabled()) {\n    dsc.sampled = String(spanIsSampled(rootSpan));\n  }\n\n  client.emit('createDsc', dsc, rootSpan);\n\n  return dsc;\n}\n\n/**\n * Convert a Span to a baggage header.\n */\nfunction spanToBaggageHeader(span) {\n  const dsc = getDynamicSamplingContextFromSpan(span);\n  return dynamicSamplingContextToSentryBaggageHeader(dsc);\n}\n\nexport { freezeDscOnSpan, getDynamicSamplingContextFromClient, getDynamicSamplingContextFromScope, getDynamicSamplingContextFromSpan, spanToBaggageHeader };\n//# sourceMappingURL=dynamicSamplingContext.js.map\n","import { DEBUG_BUILD } from '../debug-build.js';\nimport { addGlobalErrorInstrumentationHandler } from '../utils-hoist/instrument/globalError.js';\nimport { addGlobalUnhandledRejectionInstrumentationHandler } from '../utils-hoist/instrument/globalUnhandledRejection.js';\nimport { logger } from '../utils-hoist/logger.js';\nimport { getActiveSpan, getRootSpan } from '../utils/spanUtils.js';\nimport { SPAN_STATUS_ERROR } from './spanstatus.js';\n\nlet errorsInstrumented = false;\n\n/**\n * Ensure that global errors automatically set the active span status.\n */\nfunction registerSpanErrorInstrumentation() {\n  if (errorsInstrumented) {\n    return;\n  }\n\n  errorsInstrumented = true;\n  addGlobalErrorInstrumentationHandler(errorCallback);\n  addGlobalUnhandledRejectionInstrumentationHandler(errorCallback);\n}\n\n/**\n * If an error or unhandled promise occurs, we mark the active root span as failed\n */\nfunction errorCallback() {\n  const activeSpan = getActiveSpan();\n  const rootSpan = activeSpan && getRootSpan(activeSpan);\n  if (rootSpan) {\n    const message = 'internal_error';\n    DEBUG_BUILD && logger.log(`[Tracing] Root span: ${message} -> Global error occurred`);\n    rootSpan.setStatus({ code: SPAN_STATUS_ERROR, message });\n  }\n}\n\n// The function name will be lost when bundling but we need to be able to identify this listener later to maintain the\n// node.js default exit behaviour\nerrorCallback.tag = 'sentry_tracingErrorCallback';\n\nexport { registerSpanErrorInstrumentation };\n//# sourceMappingURL=errors.js.map\n","import { registerSpanErrorInstrumentation } from './errors.js';\n\n/**\n * @deprecated Use `registerSpanErrorInstrumentation()` instead. In v9, this function will be removed. Note that you don't need to call this in Node-based SDKs or when using `browserTracingIntegration`.\n */\nfunction addTracingExtensions() {\n  registerSpanErrorInstrumentation();\n}\n\nexport { addTracingExtensions };\n//# sourceMappingURL=hubextensions.js.map\n","import { getClient, getCurrentScope } from '../currentScopes.js';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON } from '../semanticAttributes.js';\nimport { logger } from '../utils-hoist/logger.js';\nimport { timestampInSeconds } from '../utils-hoist/time.js';\nimport { hasTracingEnabled } from '../utils/hasTracingEnabled.js';\nimport { _setSpanForScope } from '../utils/spanOnScope.js';\nimport { getActiveSpan, spanTimeInputToSeconds, getSpanDescendants, spanToJSON, removeChildSpanFromSpan } from '../utils/spanUtils.js';\nimport { SentryNonRecordingSpan } from './sentryNonRecordingSpan.js';\nimport { SPAN_STATUS_ERROR } from './spanstatus.js';\nimport { startInactiveSpan } from './trace.js';\n\nconst TRACING_DEFAULTS = {\n  idleTimeout: 1000,\n  finalTimeout: 30000,\n  childSpanTimeout: 15000,\n};\n\nconst FINISH_REASON_HEARTBEAT_FAILED = 'heartbeatFailed';\nconst FINISH_REASON_IDLE_TIMEOUT = 'idleTimeout';\nconst FINISH_REASON_FINAL_TIMEOUT = 'finalTimeout';\nconst FINISH_REASON_EXTERNAL_FINISH = 'externalFinish';\n\n/**\n * An idle span is a span that automatically finishes. It does this by tracking child spans as activities.\n * An idle span is always the active span.\n */\nfunction startIdleSpan(startSpanOptions, options = {}) {\n  // Activities store a list of active spans\n  const activities = new Map();\n\n  // We should not use heartbeat if we finished a span\n  let _finished = false;\n\n  // Timer that tracks idleTimeout\n  let _idleTimeoutID;\n\n  // The reason why the span was finished\n  let _finishReason = FINISH_REASON_EXTERNAL_FINISH;\n\n  let _autoFinishAllowed = !options.disableAutoFinish;\n\n  const _cleanupHooks = [];\n\n  const {\n    idleTimeout = TRACING_DEFAULTS.idleTimeout,\n    finalTimeout = TRACING_DEFAULTS.finalTimeout,\n    childSpanTimeout = TRACING_DEFAULTS.childSpanTimeout,\n    beforeSpanEnd,\n  } = options;\n\n  const client = getClient();\n\n  if (!client || !hasTracingEnabled()) {\n    return new SentryNonRecordingSpan();\n  }\n\n  const scope = getCurrentScope();\n  const previousActiveSpan = getActiveSpan();\n  const span = _startIdleSpan(startSpanOptions);\n\n  // We patch span.end to ensure we can run some things before the span is ended\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  span.end = new Proxy(span.end, {\n    apply(target, thisArg, args) {\n      if (beforeSpanEnd) {\n        beforeSpanEnd(span);\n      }\n\n      // Just ensuring that this keeps working, even if we ever have more arguments here\n      const [definedEndTimestamp, ...rest] = args;\n      const timestamp = definedEndTimestamp || timestampInSeconds();\n      const spanEndTimestamp = spanTimeInputToSeconds(timestamp);\n\n      // Ensure we end with the last span timestamp, if possible\n      const spans = getSpanDescendants(span).filter(child => child !== span);\n\n      // If we have no spans, we just end, nothing else to do here\n      if (!spans.length) {\n        onIdleSpanEnded(spanEndTimestamp);\n        return Reflect.apply(target, thisArg, [spanEndTimestamp, ...rest]);\n      }\n\n      const childEndTimestamps = spans\n        .map(span => spanToJSON(span).timestamp)\n        .filter(timestamp => !!timestamp) ;\n      const latestSpanEndTimestamp = childEndTimestamps.length ? Math.max(...childEndTimestamps) : undefined;\n\n      // In reality this should always exist here, but type-wise it may be undefined...\n      const spanStartTimestamp = spanToJSON(span).start_timestamp;\n\n      // The final endTimestamp should:\n      // * Never be before the span start timestamp\n      // * Be the latestSpanEndTimestamp, if there is one, and it is smaller than the passed span end timestamp\n      // * Otherwise be the passed end timestamp\n      // Final timestamp can never be after finalTimeout\n      const endTimestamp = Math.min(\n        spanStartTimestamp ? spanStartTimestamp + finalTimeout / 1000 : Infinity,\n        Math.max(spanStartTimestamp || -Infinity, Math.min(spanEndTimestamp, latestSpanEndTimestamp || Infinity)),\n      );\n\n      onIdleSpanEnded(endTimestamp);\n      return Reflect.apply(target, thisArg, [endTimestamp, ...rest]);\n    },\n  });\n\n  /**\n   * Cancels the existing idle timeout, if there is one.\n   */\n  function _cancelIdleTimeout() {\n    if (_idleTimeoutID) {\n      clearTimeout(_idleTimeoutID);\n      _idleTimeoutID = undefined;\n    }\n  }\n\n  /**\n   * Restarts idle timeout, if there is no running idle timeout it will start one.\n   */\n  function _restartIdleTimeout(endTimestamp) {\n    _cancelIdleTimeout();\n    _idleTimeoutID = setTimeout(() => {\n      if (!_finished && activities.size === 0 && _autoFinishAllowed) {\n        _finishReason = FINISH_REASON_IDLE_TIMEOUT;\n        span.end(endTimestamp);\n      }\n    }, idleTimeout);\n  }\n\n  /**\n   * Restarts child span timeout, if there is none running it will start one.\n   */\n  function _restartChildSpanTimeout(endTimestamp) {\n    _idleTimeoutID = setTimeout(() => {\n      if (!_finished && _autoFinishAllowed) {\n        _finishReason = FINISH_REASON_HEARTBEAT_FAILED;\n        span.end(endTimestamp);\n      }\n    }, childSpanTimeout);\n  }\n\n  /**\n   * Start tracking a specific activity.\n   * @param spanId The span id that represents the activity\n   */\n  function _pushActivity(spanId) {\n    _cancelIdleTimeout();\n    activities.set(spanId, true);\n\n    const endTimestamp = timestampInSeconds();\n    // We need to add the timeout here to have the real endtimestamp of the idle span\n    // Remember timestampInSeconds is in seconds, timeout is in ms\n    _restartChildSpanTimeout(endTimestamp + childSpanTimeout / 1000);\n  }\n\n  /**\n   * Remove an activity from usage\n   * @param spanId The span id that represents the activity\n   */\n  function _popActivity(spanId) {\n    if (activities.has(spanId)) {\n      activities.delete(spanId);\n    }\n\n    if (activities.size === 0) {\n      const endTimestamp = timestampInSeconds();\n      // We need to add the timeout here to have the real endtimestamp of the idle span\n      // Remember timestampInSeconds is in seconds, timeout is in ms\n      _restartIdleTimeout(endTimestamp + idleTimeout / 1000);\n    }\n  }\n\n  function onIdleSpanEnded(endTimestamp) {\n    _finished = true;\n    activities.clear();\n\n    _cleanupHooks.forEach(cleanup => cleanup());\n\n    _setSpanForScope(scope, previousActiveSpan);\n\n    const spanJSON = spanToJSON(span);\n\n    const { start_timestamp: startTimestamp } = spanJSON;\n    // This should never happen, but to make TS happy...\n    if (!startTimestamp) {\n      return;\n    }\n\n    const attributes = spanJSON.data || {};\n    if (!attributes[SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON]) {\n      span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON, _finishReason);\n    }\n\n    logger.log(`[Tracing] Idle span \"${spanJSON.op}\" finished`);\n\n    const childSpans = getSpanDescendants(span).filter(child => child !== span);\n\n    let discardedSpans = 0;\n    childSpans.forEach(childSpan => {\n      // We cancel all pending spans with status \"cancelled\" to indicate the idle span was finished early\n      if (childSpan.isRecording()) {\n        childSpan.setStatus({ code: SPAN_STATUS_ERROR, message: 'cancelled' });\n        childSpan.end(endTimestamp);\n        DEBUG_BUILD &&\n          logger.log('[Tracing] Cancelling span since span ended early', JSON.stringify(childSpan, undefined, 2));\n      }\n\n      const childSpanJSON = spanToJSON(childSpan);\n      const { timestamp: childEndTimestamp = 0, start_timestamp: childStartTimestamp = 0 } = childSpanJSON;\n\n      const spanStartedBeforeIdleSpanEnd = childStartTimestamp <= endTimestamp;\n\n      // Add a delta with idle timeout so that we prevent false positives\n      const timeoutWithMarginOfError = (finalTimeout + idleTimeout) / 1000;\n      const spanEndedBeforeFinalTimeout = childEndTimestamp - childStartTimestamp <= timeoutWithMarginOfError;\n\n      if (DEBUG_BUILD) {\n        const stringifiedSpan = JSON.stringify(childSpan, undefined, 2);\n        if (!spanStartedBeforeIdleSpanEnd) {\n          logger.log('[Tracing] Discarding span since it happened after idle span was finished', stringifiedSpan);\n        } else if (!spanEndedBeforeFinalTimeout) {\n          logger.log('[Tracing] Discarding span since it finished after idle span final timeout', stringifiedSpan);\n        }\n      }\n\n      if (!spanEndedBeforeFinalTimeout || !spanStartedBeforeIdleSpanEnd) {\n        removeChildSpanFromSpan(span, childSpan);\n        discardedSpans++;\n      }\n    });\n\n    if (discardedSpans > 0) {\n      span.setAttribute('sentry.idle_span_discarded_spans', discardedSpans);\n    }\n  }\n\n  _cleanupHooks.push(\n    client.on('spanStart', startedSpan => {\n      // If we already finished the idle span,\n      // or if this is the idle span itself being started,\n      // or if the started span has already been closed,\n      // we don't care about it for activity\n      if (_finished || startedSpan === span || !!spanToJSON(startedSpan).timestamp) {\n        return;\n      }\n\n      const allSpans = getSpanDescendants(span);\n\n      // If the span that was just started is a child of the idle span, we should track it\n      if (allSpans.includes(startedSpan)) {\n        _pushActivity(startedSpan.spanContext().spanId);\n      }\n    }),\n  );\n\n  _cleanupHooks.push(\n    client.on('spanEnd', endedSpan => {\n      if (_finished) {\n        return;\n      }\n\n      _popActivity(endedSpan.spanContext().spanId);\n    }),\n  );\n\n  _cleanupHooks.push(\n    client.on('idleSpanEnableAutoFinish', spanToAllowAutoFinish => {\n      if (spanToAllowAutoFinish === span) {\n        _autoFinishAllowed = true;\n        _restartIdleTimeout();\n\n        if (activities.size) {\n          _restartChildSpanTimeout();\n        }\n      }\n    }),\n  );\n\n  // We only start the initial idle timeout if we are not delaying the auto finish\n  if (!options.disableAutoFinish) {\n    _restartIdleTimeout();\n  }\n\n  setTimeout(() => {\n    if (!_finished) {\n      span.setStatus({ code: SPAN_STATUS_ERROR, message: 'deadline_exceeded' });\n      _finishReason = FINISH_REASON_FINAL_TIMEOUT;\n      span.end();\n    }\n  }, finalTimeout);\n\n  return span;\n}\n\nfunction _startIdleSpan(options) {\n  const span = startInactiveSpan(options);\n\n  _setSpanForScope(getCurrentScope(), span);\n\n  DEBUG_BUILD && logger.log('[Tracing] Started span is an idle span');\n\n  return span;\n}\n\nexport { TRACING_DEFAULTS, startIdleSpan };\n//# sourceMappingURL=idleSpan.js.map\n","import { DEBUG_BUILD } from '../debug-build.js';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE, SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT } from '../semanticAttributes.js';\nimport { logger } from '../utils-hoist/logger.js';\nimport { getRootSpan, getActiveSpan } from '../utils/spanUtils.js';\n\n/**\n * Adds a measurement to the active transaction on the current global scope. You can optionally pass in a different span\n * as the 4th parameter.\n */\nfunction setMeasurement(name, value, unit, activeSpan = getActiveSpan()) {\n  const rootSpan = activeSpan && getRootSpan(activeSpan);\n\n  if (rootSpan) {\n    DEBUG_BUILD && logger.log(`[Measurement] Setting measurement on root span: ${name} = ${value} ${unit}`);\n    rootSpan.addEvent(name, {\n      [SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE]: value,\n      [SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT]: unit ,\n    });\n  }\n}\n\n/**\n * Convert timed events to measurements.\n */\nfunction timedEventsToMeasurements(events) {\n  if (!events || events.length === 0) {\n    return undefined;\n  }\n\n  const measurements = {};\n  events.forEach(event => {\n    const attributes = event.attributes || {};\n    const unit = attributes[SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT] ;\n    const value = attributes[SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE] ;\n\n    if (typeof unit === 'string' && typeof value === 'number') {\n      measurements[event.name] = { value, unit };\n    }\n  });\n\n  return measurements;\n}\n\nexport { setMeasurement, timedEventsToMeasurements };\n//# sourceMappingURL=measurement.js.map\n","import { generateTraceId, generateSpanId } from '../utils-hoist/propagationContext.js';\nimport { TRACE_FLAG_NONE } from '../utils/spanUtils.js';\n\n/**\n * A Sentry Span that is non-recording, meaning it will not be sent to Sentry.\n */\nclass SentryNonRecordingSpan  {\n\n   constructor(spanContext = {}) {\n    this._traceId = spanContext.traceId || generateTraceId();\n    this._spanId = spanContext.spanId || generateSpanId();\n  }\n\n  /** @inheritdoc */\n   spanContext() {\n    return {\n      spanId: this._spanId,\n      traceId: this._traceId,\n      traceFlags: TRACE_FLAG_NONE,\n    };\n  }\n\n  /** @inheritdoc */\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n   end(_timestamp) {}\n\n  /** @inheritdoc */\n   setAttribute(_key, _value) {\n    return this;\n  }\n\n  /** @inheritdoc */\n   setAttributes(_values) {\n    return this;\n  }\n\n  /** @inheritdoc */\n   setStatus(_status) {\n    return this;\n  }\n\n  /** @inheritdoc */\n   updateName(_name) {\n    return this;\n  }\n\n  /** @inheritdoc */\n   isRecording() {\n    return false;\n  }\n\n  /** @inheritdoc */\n   addEvent(\n    _name,\n    _attributesOrStartTime,\n    _startTime,\n  ) {\n    return this;\n  }\n\n  /**\n   * This should generally not be used,\n   * but we need it for being compliant with the OTEL Span interface.\n   *\n   * @hidden\n   * @internal\n   */\n   addLink(_link) {\n    return this;\n  }\n\n  /**\n   * This should generally not be used,\n   * but we need it for being compliant with the OTEL Span interface.\n   *\n   * @hidden\n   * @internal\n   */\n   addLinks(_links) {\n    return this;\n  }\n\n  /**\n   * This should generally not be used,\n   * but we need it for being compliant with the OTEL Span interface.\n   *\n   * @hidden\n   * @internal\n   */\n   recordException(_exception, _time) {\n    // noop\n  }\n}\n\nexport { SentryNonRecordingSpan };\n//# sourceMappingURL=sentryNonRecordingSpan.js.map\n","const SPAN_STATUS_UNSET = 0;\nconst SPAN_STATUS_OK = 1;\nconst SPAN_STATUS_ERROR = 2;\n\n/**\n * Converts a HTTP status code into a sentry status with a message.\n *\n * @param httpStatus The HTTP response status code.\n * @returns The span status or unknown_error.\n */\n// https://develop.sentry.dev/sdk/event-payloads/span/\nfunction getSpanStatusFromHttpCode(httpStatus) {\n  if (httpStatus < 400 && httpStatus >= 100) {\n    return { code: SPAN_STATUS_OK };\n  }\n\n  if (httpStatus >= 400 && httpStatus < 500) {\n    switch (httpStatus) {\n      case 401:\n        return { code: SPAN_STATUS_ERROR, message: 'unauthenticated' };\n      case 403:\n        return { code: SPAN_STATUS_ERROR, message: 'permission_denied' };\n      case 404:\n        return { code: SPAN_STATUS_ERROR, message: 'not_found' };\n      case 409:\n        return { code: SPAN_STATUS_ERROR, message: 'already_exists' };\n      case 413:\n        return { code: SPAN_STATUS_ERROR, message: 'failed_precondition' };\n      case 429:\n        return { code: SPAN_STATUS_ERROR, message: 'resource_exhausted' };\n      case 499:\n        return { code: SPAN_STATUS_ERROR, message: 'cancelled' };\n      default:\n        return { code: SPAN_STATUS_ERROR, message: 'invalid_argument' };\n    }\n  }\n\n  if (httpStatus >= 500 && httpStatus < 600) {\n    switch (httpStatus) {\n      case 501:\n        return { code: SPAN_STATUS_ERROR, message: 'unimplemented' };\n      case 503:\n        return { code: SPAN_STATUS_ERROR, message: 'unavailable' };\n      case 504:\n        return { code: SPAN_STATUS_ERROR, message: 'deadline_exceeded' };\n      default:\n        return { code: SPAN_STATUS_ERROR, message: 'internal_error' };\n    }\n  }\n\n  return { code: SPAN_STATUS_ERROR, message: 'unknown_error' };\n}\n\n/**\n * Sets the Http status attributes on the current span based on the http code.\n * Additionally, the span's status is updated, depending on the http code.\n */\nfunction setHttpStatus(span, httpStatus) {\n  span.setAttribute('http.response.status_code', httpStatus);\n\n  const spanStatus = getSpanStatusFromHttpCode(httpStatus);\n  if (spanStatus.message !== 'unknown_error') {\n    span.setStatus(spanStatus);\n  }\n}\n\nexport { SPAN_STATUS_ERROR, SPAN_STATUS_OK, SPAN_STATUS_UNSET, getSpanStatusFromHttpCode, setHttpStatus };\n//# sourceMappingURL=spanstatus.js.map\n","import { addNonEnumerableProperty } from '../utils-hoist/object.js';\n\nconst SCOPE_ON_START_SPAN_FIELD = '_sentryScope';\nconst ISOLATION_SCOPE_ON_START_SPAN_FIELD = '_sentryIsolationScope';\n\n/** Store the scope & isolation scope for a span, which can the be used when it is finished. */\nfunction setCapturedScopesOnSpan(span, scope, isolationScope) {\n  if (span) {\n    addNonEnumerableProperty(span, ISOLATION_SCOPE_ON_START_SPAN_FIELD, isolationScope);\n    addNonEnumerableProperty(span, SCOPE_ON_START_SPAN_FIELD, scope);\n  }\n}\n\n/**\n * Grabs the scope and isolation scope off a span that were active when the span was started.\n */\nfunction getCapturedScopesOnSpan(span) {\n  return {\n    scope: (span )[SCOPE_ON_START_SPAN_FIELD],\n    isolationScope: (span )[ISOLATION_SCOPE_ON_START_SPAN_FIELD],\n  };\n}\n\nexport { getCapturedScopesOnSpan, setCapturedScopesOnSpan };\n//# sourceMappingURL=utils.js.map\n","import { getClient, getCurrentScope } from '../currentScopes.js';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { createSpanEnvelope } from '../envelope.js';\nimport { getMetricSummaryJsonForSpan } from '../metrics/metric-summary.js';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_PROFILE_ID, SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME } from '../semanticAttributes.js';\nimport { logger } from '../utils-hoist/logger.js';\nimport { dropUndefinedKeys } from '../utils-hoist/object.js';\nimport { generateTraceId, generateSpanId } from '../utils-hoist/propagationContext.js';\nimport { timestampInSeconds } from '../utils-hoist/time.js';\nimport { TRACE_FLAG_SAMPLED, TRACE_FLAG_NONE, spanTimeInputToSeconds, getStatusMessage, getRootSpan, spanToJSON, getSpanDescendants, spanToTransactionTraceContext } from '../utils/spanUtils.js';\nimport { getDynamicSamplingContextFromSpan } from './dynamicSamplingContext.js';\nimport { logSpanEnd } from './logSpans.js';\nimport { timedEventsToMeasurements } from './measurement.js';\nimport { getCapturedScopesOnSpan } from './utils.js';\n\nconst MAX_SPAN_COUNT = 1000;\n\n/**\n * Span contains all data about a span\n */\nclass SentrySpan  {\n\n  /** Epoch timestamp in seconds when the span started. */\n\n  /** Epoch timestamp in seconds when the span ended. */\n\n  /** Internal keeper of the status */\n\n  /** The timed events added to this span. */\n\n  /** if true, treat span as a standalone span (not part of a transaction) */\n\n  /**\n   * You should never call the constructor manually, always use `Sentry.startSpan()`\n   * or other span methods.\n   * @internal\n   * @hideconstructor\n   * @hidden\n   */\n   constructor(spanContext = {}) {\n    this._traceId = spanContext.traceId || generateTraceId();\n    this._spanId = spanContext.spanId || generateSpanId();\n    this._startTime = spanContext.startTimestamp || timestampInSeconds();\n\n    this._attributes = {};\n    this.setAttributes({\n      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'manual',\n      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: spanContext.op,\n      ...spanContext.attributes,\n    });\n\n    this._name = spanContext.name;\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.endTimestamp) {\n      this._endTime = spanContext.endTimestamp;\n    }\n\n    this._events = [];\n\n    this._isStandaloneSpan = spanContext.isStandalone;\n\n    // If the span is already ended, ensure we finalize the span immediately\n    if (this._endTime) {\n      this._onSpanEnded();\n    }\n  }\n\n  /**\n   * This should generally not be used,\n   * but it is needed for being compliant with the OTEL Span interface.\n   *\n   * @hidden\n   * @internal\n   */\n   addLink(_link) {\n    return this;\n  }\n\n  /**\n   * This should generally not be used,\n   * but it is needed for being compliant with the OTEL Span interface.\n   *\n   * @hidden\n   * @internal\n   */\n   addLinks(_links) {\n    return this;\n  }\n\n  /**\n   * This should generally not be used,\n   * but it is needed for being compliant with the OTEL Span interface.\n   *\n   * @hidden\n   * @internal\n   */\n   recordException(_exception, _time) {\n    // noop\n  }\n\n  /** @inheritdoc */\n   spanContext() {\n    const { _spanId: spanId, _traceId: traceId, _sampled: sampled } = this;\n    return {\n      spanId,\n      traceId,\n      traceFlags: sampled ? TRACE_FLAG_SAMPLED : TRACE_FLAG_NONE,\n    };\n  }\n\n  /** @inheritdoc */\n   setAttribute(key, value) {\n    if (value === undefined) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete this._attributes[key];\n    } else {\n      this._attributes[key] = value;\n    }\n\n    return this;\n  }\n\n  /** @inheritdoc */\n   setAttributes(attributes) {\n    Object.keys(attributes).forEach(key => this.setAttribute(key, attributes[key]));\n    return this;\n  }\n\n  /**\n   * This should generally not be used,\n   * but we need it for browser tracing where we want to adjust the start time afterwards.\n   * USE THIS WITH CAUTION!\n   *\n   * @hidden\n   * @internal\n   */\n   updateStartTime(timeInput) {\n    this._startTime = spanTimeInputToSeconds(timeInput);\n  }\n\n  /**\n   * @inheritDoc\n   */\n   setStatus(value) {\n    this._status = value;\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n   updateName(name) {\n    this._name = name;\n    this.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, 'custom');\n    return this;\n  }\n\n  /** @inheritdoc */\n   end(endTimestamp) {\n    // If already ended, skip\n    if (this._endTime) {\n      return;\n    }\n\n    this._endTime = spanTimeInputToSeconds(endTimestamp);\n    logSpanEnd(this);\n\n    this._onSpanEnded();\n  }\n\n  /**\n   * Get JSON representation of this span.\n   *\n   * @hidden\n   * @internal This method is purely for internal purposes and should not be used outside\n   * of SDK code. If you need to get a JSON representation of a span,\n   * use `spanToJSON(span)` instead.\n   */\n   getSpanJSON() {\n    return dropUndefinedKeys({\n      data: this._attributes,\n      description: this._name,\n      op: this._attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP],\n      parent_span_id: this._parentSpanId,\n      span_id: this._spanId,\n      start_timestamp: this._startTime,\n      status: getStatusMessage(this._status),\n      timestamp: this._endTime,\n      trace_id: this._traceId,\n      origin: this._attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] ,\n      _metrics_summary: getMetricSummaryJsonForSpan(this),\n      profile_id: this._attributes[SEMANTIC_ATTRIBUTE_PROFILE_ID] ,\n      exclusive_time: this._attributes[SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME] ,\n      measurements: timedEventsToMeasurements(this._events),\n      is_segment: (this._isStandaloneSpan && getRootSpan(this) === this) || undefined,\n      segment_id: this._isStandaloneSpan ? getRootSpan(this).spanContext().spanId : undefined,\n    });\n  }\n\n  /** @inheritdoc */\n   isRecording() {\n    return !this._endTime && !!this._sampled;\n  }\n\n  /**\n   * @inheritdoc\n   */\n   addEvent(\n    name,\n    attributesOrStartTime,\n    startTime,\n  ) {\n    DEBUG_BUILD && logger.log('[Tracing] Adding an event to span:', name);\n\n    const time = isSpanTimeInput(attributesOrStartTime) ? attributesOrStartTime : startTime || timestampInSeconds();\n    const attributes = isSpanTimeInput(attributesOrStartTime) ? {} : attributesOrStartTime || {};\n\n    const event = {\n      name,\n      time: spanTimeInputToSeconds(time),\n      attributes,\n    };\n\n    this._events.push(event);\n\n    return this;\n  }\n\n  /**\n   * This method should generally not be used,\n   * but for now we need a way to publicly check if the `_isStandaloneSpan` flag is set.\n   * USE THIS WITH CAUTION!\n   * @internal\n   * @hidden\n   * @experimental\n   */\n   isStandaloneSpan() {\n    return !!this._isStandaloneSpan;\n  }\n\n  /** Emit `spanEnd` when the span is ended. */\n   _onSpanEnded() {\n    const client = getClient();\n    if (client) {\n      client.emit('spanEnd', this);\n    }\n\n    // A segment span is basically the root span of a local span tree.\n    // So for now, this is either what we previously refer to as the root span,\n    // or a standalone span.\n    const isSegmentSpan = this._isStandaloneSpan || this === getRootSpan(this);\n\n    if (!isSegmentSpan) {\n      return;\n    }\n\n    // if this is a standalone span, we send it immediately\n    if (this._isStandaloneSpan) {\n      if (this._sampled) {\n        sendSpanEnvelope(createSpanEnvelope([this], client));\n      } else {\n        DEBUG_BUILD &&\n          logger.log('[Tracing] Discarding standalone span because its trace was not chosen to be sampled.');\n        if (client) {\n          client.recordDroppedEvent('sample_rate', 'span');\n        }\n      }\n      return;\n    }\n\n    const transactionEvent = this._convertSpanToTransaction();\n    if (transactionEvent) {\n      const scope = getCapturedScopesOnSpan(this).scope || getCurrentScope();\n      scope.captureEvent(transactionEvent);\n    }\n  }\n\n  /**\n   * Finish the transaction & prepare the event to send to Sentry.\n   */\n   _convertSpanToTransaction() {\n    // We can only convert finished spans\n    if (!isFullFinishedSpan(spanToJSON(this))) {\n      return undefined;\n    }\n\n    if (!this._name) {\n      DEBUG_BUILD && logger.warn('Transaction has no name, falling back to `<unlabeled transaction>`.');\n      this._name = '<unlabeled transaction>';\n    }\n\n    const { scope: capturedSpanScope, isolationScope: capturedSpanIsolationScope } = getCapturedScopesOnSpan(this);\n    const scope = capturedSpanScope || getCurrentScope();\n    const client = scope.getClient() || getClient();\n\n    if (this._sampled !== true) {\n      // At this point if `sampled !== true` we want to discard the transaction.\n      DEBUG_BUILD && logger.log('[Tracing] Discarding transaction because its trace was not chosen to be sampled.');\n\n      if (client) {\n        client.recordDroppedEvent('sample_rate', 'transaction');\n      }\n\n      return undefined;\n    }\n\n    // The transaction span itself as well as any potential standalone spans should be filtered out\n    const finishedSpans = getSpanDescendants(this).filter(span => span !== this && !isStandaloneSpan(span));\n\n    const spans = finishedSpans.map(span => spanToJSON(span)).filter(isFullFinishedSpan);\n\n    const source = this._attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] ;\n\n    const transaction = {\n      contexts: {\n        trace: spanToTransactionTraceContext(this),\n      },\n      spans:\n        // spans.sort() mutates the array, but `spans` is already a copy so we can safely do this here\n        // we do not use spans anymore after this point\n        spans.length > MAX_SPAN_COUNT\n          ? spans.sort((a, b) => a.start_timestamp - b.start_timestamp).slice(0, MAX_SPAN_COUNT)\n          : spans,\n      start_timestamp: this._startTime,\n      timestamp: this._endTime,\n      transaction: this._name,\n      type: 'transaction',\n      sdkProcessingMetadata: {\n        capturedSpanScope,\n        capturedSpanIsolationScope,\n        ...dropUndefinedKeys({\n          dynamicSamplingContext: getDynamicSamplingContextFromSpan(this),\n        }),\n      },\n      _metrics_summary: getMetricSummaryJsonForSpan(this),\n      ...(source && {\n        transaction_info: {\n          source,\n        },\n      }),\n    };\n\n    const measurements = timedEventsToMeasurements(this._events);\n    const hasMeasurements = measurements && Object.keys(measurements).length;\n\n    if (hasMeasurements) {\n      DEBUG_BUILD &&\n        logger.log(\n          '[Measurements] Adding measurements to transaction event',\n          JSON.stringify(measurements, undefined, 2),\n        );\n      transaction.measurements = measurements;\n    }\n\n    return transaction;\n  }\n}\n\nfunction isSpanTimeInput(value) {\n  return (value && typeof value === 'number') || value instanceof Date || Array.isArray(value);\n}\n\n// We want to filter out any incomplete SpanJSON objects\nfunction isFullFinishedSpan(input) {\n  return !!input.start_timestamp && !!input.timestamp && !!input.span_id && !!input.trace_id;\n}\n\n/** `SentrySpan`s can be sent as a standalone span rather than belonging to a transaction */\nfunction isStandaloneSpan(span) {\n  return span instanceof SentrySpan && span.isStandaloneSpan();\n}\n\n/**\n * Sends a `SpanEnvelope`.\n *\n * Note: If the envelope's spans are dropped, e.g. via `beforeSendSpan`,\n * the envelope will not be sent either.\n */\nfunction sendSpanEnvelope(envelope) {\n  const client = getClient();\n  if (!client) {\n    return;\n  }\n\n  const spanItems = envelope[1];\n  if (!spanItems || spanItems.length === 0) {\n    client.recordDroppedEvent('before_send', 'span');\n    return;\n  }\n\n  // sendEnvelope should not throw\n  // eslint-disable-next-line @typescript-eslint/no-floating-promises\n  client.sendEnvelope(envelope);\n}\n\nexport { SentrySpan };\n//# sourceMappingURL=sentrySpan.js.map\n","import { DEBUG_BUILD } from '../debug-build.js';\nimport { logger } from '../utils-hoist/logger.js';\nimport { spanToJSON, spanIsSampled, getRootSpan } from '../utils/spanUtils.js';\n\n/**\n * Print a log message for a started span.\n */\nfunction logSpanStart(span) {\n  if (!DEBUG_BUILD) return;\n\n  const { description = '< unknown name >', op = '< unknown op >', parent_span_id: parentSpanId } = spanToJSON(span);\n  const { spanId } = span.spanContext();\n\n  const sampled = spanIsSampled(span);\n  const rootSpan = getRootSpan(span);\n  const isRootSpan = rootSpan === span;\n\n  const header = `[Tracing] Starting ${sampled ? 'sampled' : 'unsampled'} ${isRootSpan ? 'root ' : ''}span`;\n\n  const infoParts = [`op: ${op}`, `name: ${description}`, `ID: ${spanId}`];\n\n  if (parentSpanId) {\n    infoParts.push(`parent ID: ${parentSpanId}`);\n  }\n\n  if (!isRootSpan) {\n    const { op, description } = spanToJSON(rootSpan);\n    infoParts.push(`root ID: ${rootSpan.spanContext().spanId}`);\n    if (op) {\n      infoParts.push(`root op: ${op}`);\n    }\n    if (description) {\n      infoParts.push(`root description: ${description}`);\n    }\n  }\n\n  logger.log(`${header}\n  ${infoParts.join('\\n  ')}`);\n}\n\n/**\n * Print a log message for an ended span.\n */\nfunction logSpanEnd(span) {\n  if (!DEBUG_BUILD) return;\n\n  const { description = '< unknown name >', op = '< unknown op >' } = spanToJSON(span);\n  const { spanId } = span.spanContext();\n  const rootSpan = getRootSpan(span);\n  const isRootSpan = rootSpan === span;\n\n  const msg = `[Tracing] Finishing \"${op}\" ${isRootSpan ? 'root ' : ''}span \"${description}\" with ID ${spanId}`;\n  logger.log(msg);\n}\n\nexport { logSpanEnd, logSpanStart };\n//# sourceMappingURL=logSpans.js.map\n","import { getMainCarrier } from '../carrier.js';\nimport { withScope, getCurrentScope, getIsolationScope, getClient } from '../currentScopes.js';\nimport { getAsyncContextStrategy } from '../asyncContext/index.js';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '../semanticAttributes.js';\nimport { logger } from '../utils-hoist/logger.js';\nimport { generateTraceId } from '../utils-hoist/propagationContext.js';\nimport { propagationContextFromHeaders } from '../utils-hoist/tracing.js';\nimport { handleCallbackErrors } from '../utils/handleCallbackErrors.js';\nimport { hasTracingEnabled } from '../utils/hasTracingEnabled.js';\nimport { _setSpanForScope, _getSpanForScope } from '../utils/spanOnScope.js';\nimport { spanToJSON, addChildSpanToSpan, spanIsSampled, spanTimeInputToSeconds, getRootSpan } from '../utils/spanUtils.js';\nimport { getDynamicSamplingContextFromSpan, freezeDscOnSpan } from './dynamicSamplingContext.js';\nimport { logSpanStart } from './logSpans.js';\nimport { sampleSpan } from './sampling.js';\nimport { SentryNonRecordingSpan } from './sentryNonRecordingSpan.js';\nimport { SentrySpan } from './sentrySpan.js';\nimport { SPAN_STATUS_ERROR } from './spanstatus.js';\nimport { setCapturedScopesOnSpan } from './utils.js';\n\nconst SUPPRESS_TRACING_KEY = '__SENTRY_SUPPRESS_TRACING__';\n\n/**\n * Wraps a function with a transaction/span and finishes the span after the function is done.\n * The created span is the active span and will be used as parent by other spans created inside the function\n * and can be accessed via `Sentry.getActiveSpan()`, as long as the function is executed while the scope is active.\n *\n * If you want to create a span that is not set as active, use {@link startInactiveSpan}.\n *\n * You'll always get a span passed to the callback,\n * it may just be a non-recording span if the span is not sampled or if tracing is disabled.\n */\nfunction startSpan(options, callback) {\n  const acs = getAcs();\n  if (acs.startSpan) {\n    return acs.startSpan(options, callback);\n  }\n\n  const spanArguments = parseSentrySpanArguments(options);\n  const { forceTransaction, parentSpan: customParentSpan } = options;\n\n  return withScope(options.scope, () => {\n    // If `options.parentSpan` is defined, we want to wrap the callback in `withActiveSpan`\n    const wrapper = getActiveSpanWrapper(customParentSpan);\n\n    return wrapper(() => {\n      const scope = getCurrentScope();\n      const parentSpan = getParentSpan(scope);\n\n      const shouldSkipSpan = options.onlyIfParent && !parentSpan;\n      const activeSpan = shouldSkipSpan\n        ? new SentryNonRecordingSpan()\n        : createChildOrRootSpan({\n            parentSpan,\n            spanArguments,\n            forceTransaction,\n            scope,\n          });\n\n      _setSpanForScope(scope, activeSpan);\n\n      return handleCallbackErrors(\n        () => callback(activeSpan),\n        () => {\n          // Only update the span status if it hasn't been changed yet, and the span is not yet finished\n          const { status } = spanToJSON(activeSpan);\n          if (activeSpan.isRecording() && (!status || status === 'ok')) {\n            activeSpan.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_error' });\n          }\n        },\n        () => activeSpan.end(),\n      );\n    });\n  });\n}\n\n/**\n * Similar to `Sentry.startSpan`. Wraps a function with a transaction/span, but does not finish the span\n * after the function is done automatically. You'll have to call `span.end()` manually.\n *\n * The created span is the active span and will be used as parent by other spans created inside the function\n * and can be accessed via `Sentry.getActiveSpan()`, as long as the function is executed while the scope is active.\n *\n * You'll always get a span passed to the callback,\n * it may just be a non-recording span if the span is not sampled or if tracing is disabled.\n */\nfunction startSpanManual(options, callback) {\n  const acs = getAcs();\n  if (acs.startSpanManual) {\n    return acs.startSpanManual(options, callback);\n  }\n\n  const spanArguments = parseSentrySpanArguments(options);\n  const { forceTransaction, parentSpan: customParentSpan } = options;\n\n  return withScope(options.scope, () => {\n    // If `options.parentSpan` is defined, we want to wrap the callback in `withActiveSpan`\n    const wrapper = getActiveSpanWrapper(customParentSpan);\n\n    return wrapper(() => {\n      const scope = getCurrentScope();\n      const parentSpan = getParentSpan(scope);\n\n      const shouldSkipSpan = options.onlyIfParent && !parentSpan;\n      const activeSpan = shouldSkipSpan\n        ? new SentryNonRecordingSpan()\n        : createChildOrRootSpan({\n            parentSpan,\n            spanArguments,\n            forceTransaction,\n            scope,\n          });\n\n      _setSpanForScope(scope, activeSpan);\n\n      function finishAndSetSpan() {\n        activeSpan.end();\n      }\n\n      return handleCallbackErrors(\n        () => callback(activeSpan, finishAndSetSpan),\n        () => {\n          // Only update the span status if it hasn't been changed yet, and the span is not yet finished\n          const { status } = spanToJSON(activeSpan);\n          if (activeSpan.isRecording() && (!status || status === 'ok')) {\n            activeSpan.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_error' });\n          }\n        },\n      );\n    });\n  });\n}\n\n/**\n * Creates a span. This span is not set as active, so will not get automatic instrumentation spans\n * as children or be able to be accessed via `Sentry.getActiveSpan()`.\n *\n * If you want to create a span that is set as active, use {@link startSpan}.\n *\n * This function will always return a span,\n * it may just be a non-recording span if the span is not sampled or if tracing is disabled.\n */\nfunction startInactiveSpan(options) {\n  const acs = getAcs();\n  if (acs.startInactiveSpan) {\n    return acs.startInactiveSpan(options);\n  }\n\n  const spanArguments = parseSentrySpanArguments(options);\n  const { forceTransaction, parentSpan: customParentSpan } = options;\n\n  // If `options.scope` is defined, we use this as as a wrapper,\n  // If `options.parentSpan` is defined, we want to wrap the callback in `withActiveSpan`\n  const wrapper = options.scope\n    ? (callback) => withScope(options.scope, callback)\n    : customParentSpan !== undefined\n      ? (callback) => withActiveSpan(customParentSpan, callback)\n      : (callback) => callback();\n\n  return wrapper(() => {\n    const scope = getCurrentScope();\n    const parentSpan = getParentSpan(scope);\n\n    const shouldSkipSpan = options.onlyIfParent && !parentSpan;\n\n    if (shouldSkipSpan) {\n      return new SentryNonRecordingSpan();\n    }\n\n    return createChildOrRootSpan({\n      parentSpan,\n      spanArguments,\n      forceTransaction,\n      scope,\n    });\n  });\n}\n\n/**\n * Continue a trace from `sentry-trace` and `baggage` values.\n * These values can be obtained from incoming request headers, or in the browser from `<meta name=\"sentry-trace\">`\n * and `<meta name=\"baggage\">` HTML tags.\n *\n * Spans started with `startSpan`, `startSpanManual` and `startInactiveSpan`, within the callback will automatically\n * be attached to the incoming trace.\n */\nconst continueTrace = (\n  {\n    sentryTrace,\n    baggage,\n  }\n\n,\n  callback,\n) => {\n  return withScope(scope => {\n    const propagationContext = propagationContextFromHeaders(sentryTrace, baggage);\n    scope.setPropagationContext(propagationContext);\n    return callback();\n  });\n};\n\n/**\n * Forks the current scope and sets the provided span as active span in the context of the provided callback. Can be\n * passed `null` to start an entirely new span tree.\n *\n * @param span Spans started in the context of the provided callback will be children of this span. If `null` is passed,\n * spans started within the callback will not be attached to a parent span.\n * @param callback Execution context in which the provided span will be active. Is passed the newly forked scope.\n * @returns the value returned from the provided callback function.\n */\nfunction withActiveSpan(span, callback) {\n  const acs = getAcs();\n  if (acs.withActiveSpan) {\n    return acs.withActiveSpan(span, callback);\n  }\n\n  return withScope(scope => {\n    _setSpanForScope(scope, span || undefined);\n    return callback(scope);\n  });\n}\n\n/** Suppress tracing in the given callback, ensuring no spans are generated inside of it. */\nfunction suppressTracing(callback) {\n  const acs = getAcs();\n\n  if (acs.suppressTracing) {\n    return acs.suppressTracing(callback);\n  }\n\n  return withScope(scope => {\n    scope.setSDKProcessingMetadata({ [SUPPRESS_TRACING_KEY]: true });\n    return callback();\n  });\n}\n\n/**\n * Starts a new trace for the duration of the provided callback. Spans started within the\n * callback will be part of the new trace instead of a potentially previously started trace.\n *\n * Important: Only use this function if you want to override the default trace lifetime and\n * propagation mechanism of the SDK for the duration and scope of the provided callback.\n * The newly created trace will also be the root of a new distributed trace, for example if\n * you make http requests within the callback.\n * This function might be useful if the operation you want to instrument should not be part\n * of a potentially ongoing trace.\n *\n * Default behavior:\n * - Server-side: A new trace is started for each incoming request.\n * - Browser: A new trace is started for each page our route. Navigating to a new route\n *            or page will automatically create a new trace.\n */\nfunction startNewTrace(callback) {\n  return withScope(scope => {\n    scope.setPropagationContext({ traceId: generateTraceId() });\n    DEBUG_BUILD && logger.info(`Starting a new trace with id ${scope.getPropagationContext().traceId}`);\n    return withActiveSpan(null, callback);\n  });\n}\n\nfunction createChildOrRootSpan({\n  parentSpan,\n  spanArguments,\n  forceTransaction,\n  scope,\n}\n\n) {\n  if (!hasTracingEnabled()) {\n    return new SentryNonRecordingSpan();\n  }\n\n  const isolationScope = getIsolationScope();\n\n  let span;\n  if (parentSpan && !forceTransaction) {\n    span = _startChildSpan(parentSpan, scope, spanArguments);\n    addChildSpanToSpan(parentSpan, span);\n  } else if (parentSpan) {\n    // If we forced a transaction but have a parent span, make sure to continue from the parent span, not the scope\n    const dsc = getDynamicSamplingContextFromSpan(parentSpan);\n    const { traceId, spanId: parentSpanId } = parentSpan.spanContext();\n    const parentSampled = spanIsSampled(parentSpan);\n\n    span = _startRootSpan(\n      {\n        traceId,\n        parentSpanId,\n        ...spanArguments,\n      },\n      scope,\n      parentSampled,\n    );\n\n    freezeDscOnSpan(span, dsc);\n  } else {\n    const {\n      traceId,\n      dsc,\n      parentSpanId,\n      sampled: parentSampled,\n    } = {\n      ...isolationScope.getPropagationContext(),\n      ...scope.getPropagationContext(),\n    };\n\n    span = _startRootSpan(\n      {\n        traceId,\n        parentSpanId,\n        ...spanArguments,\n      },\n      scope,\n      parentSampled,\n    );\n\n    if (dsc) {\n      freezeDscOnSpan(span, dsc);\n    }\n  }\n\n  logSpanStart(span);\n\n  setCapturedScopesOnSpan(span, scope, isolationScope);\n\n  return span;\n}\n\n/**\n * This converts StartSpanOptions to SentrySpanArguments.\n * For the most part (for now) we accept the same options,\n * but some of them need to be transformed.\n */\nfunction parseSentrySpanArguments(options) {\n  const exp = options.experimental || {};\n  const initialCtx = {\n    isStandalone: exp.standalone,\n    ...options,\n  };\n\n  if (options.startTime) {\n    const ctx = { ...initialCtx };\n    ctx.startTimestamp = spanTimeInputToSeconds(options.startTime);\n    delete ctx.startTime;\n    return ctx;\n  }\n\n  return initialCtx;\n}\n\nfunction getAcs() {\n  const carrier = getMainCarrier();\n  return getAsyncContextStrategy(carrier);\n}\n\nfunction _startRootSpan(spanArguments, scope, parentSampled) {\n  const client = getClient();\n  const options = (client && client.getOptions()) || {};\n\n  const { name = '', attributes } = spanArguments;\n  const [sampled, sampleRate] = scope.getScopeData().sdkProcessingMetadata[SUPPRESS_TRACING_KEY]\n    ? [false]\n    : sampleSpan(options, {\n        name,\n        parentSampled,\n        attributes,\n        transactionContext: {\n          name,\n          parentSampled,\n        },\n      });\n\n  const rootSpan = new SentrySpan({\n    ...spanArguments,\n    attributes: {\n      [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'custom',\n      ...spanArguments.attributes,\n    },\n    sampled,\n  });\n  if (sampleRate !== undefined) {\n    rootSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, sampleRate);\n  }\n\n  if (client) {\n    client.emit('spanStart', rootSpan);\n  }\n\n  return rootSpan;\n}\n\n/**\n * Creates a new `Span` while setting the current `Span.id` as `parentSpanId`.\n * This inherits the sampling decision from the parent span.\n */\nfunction _startChildSpan(parentSpan, scope, spanArguments) {\n  const { spanId, traceId } = parentSpan.spanContext();\n  const sampled = scope.getScopeData().sdkProcessingMetadata[SUPPRESS_TRACING_KEY] ? false : spanIsSampled(parentSpan);\n\n  const childSpan = sampled\n    ? new SentrySpan({\n        ...spanArguments,\n        parentSpanId: spanId,\n        traceId,\n        sampled,\n      })\n    : new SentryNonRecordingSpan({ traceId });\n\n  addChildSpanToSpan(parentSpan, childSpan);\n\n  const client = getClient();\n  if (client) {\n    client.emit('spanStart', childSpan);\n    // If it has an endTimestamp, it's already ended\n    if (spanArguments.endTimestamp) {\n      client.emit('spanEnd', childSpan);\n    }\n  }\n\n  return childSpan;\n}\n\nfunction getParentSpan(scope) {\n  const span = _getSpanForScope(scope) ;\n\n  if (!span) {\n    return undefined;\n  }\n\n  const client = getClient();\n  const options = client ? client.getOptions() : {};\n  if (options.parentSpanIsAlwaysRootSpan) {\n    return getRootSpan(span) ;\n  }\n\n  return span;\n}\n\nfunction getActiveSpanWrapper(parentSpan) {\n  return parentSpan !== undefined\n    ? (callback) => {\n        return withActiveSpan(parentSpan, callback);\n      }\n    : (callback) => callback();\n}\n\nexport { continueTrace, startInactiveSpan, startNewTrace, startSpan, startSpanManual, suppressTracing, withActiveSpan };\n//# sourceMappingURL=trace.js.map\n","import { DEBUG_BUILD } from '../debug-build.js';\nimport { logger } from '../utils-hoist/logger.js';\nimport { hasTracingEnabled } from '../utils/hasTracingEnabled.js';\nimport { parseSampleRate } from '../utils/parseSampleRate.js';\n\n/**\n * Makes a sampling decision for the given options.\n *\n * Called every time a root span is created. Only root spans which emerge with a `sampled` value of `true` will be\n * sent to Sentry.\n */\nfunction sampleSpan(\n  options,\n  samplingContext,\n) {\n  // nothing to do if tracing is not enabled\n  if (!hasTracingEnabled(options)) {\n    return [false];\n  }\n\n  // we would have bailed already if neither `tracesSampler` nor `tracesSampleRate` nor `enableTracing` 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  } else if (samplingContext.parentSampled !== undefined) {\n    sampleRate = samplingContext.parentSampled;\n  } else if (typeof options.tracesSampleRate !== 'undefined') {\n    sampleRate = options.tracesSampleRate;\n  } else {\n    // When `enableTracing === true`, we use a sample rate of 100%\n    sampleRate = 1;\n  }\n\n  // Since this is coming from the user (or from a function provided by the user), who knows what we might get.\n  // (The only valid values are booleans or numbers between 0 and 1.)\n  const parsedSampleRate = parseSampleRate(sampleRate);\n\n  if (parsedSampleRate === undefined) {\n    DEBUG_BUILD && logger.warn('[Tracing] Discarding transaction because of invalid sample rate.');\n    return [false];\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 (!parsedSampleRate) {\n    DEBUG_BUILD &&\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    return [false, parsedSampleRate];\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  const shouldSample = Math.random() < parsedSampleRate;\n\n  // if we're not going to keep it, we're done\n  if (!shouldSample) {\n    DEBUG_BUILD &&\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 [false, parsedSampleRate];\n  }\n\n  return [true, parsedSampleRate];\n}\n\nexport { sampleSpan };\n//# sourceMappingURL=sampling.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] || Promise.resolve(undefined);\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          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","import { DEBUG_BUILD } from '../debug-build.js';\nimport { forEachEnvelopeItem, envelopeItemTypeToDataCategory, createEnvelope, serializeEnvelope } from '../utils-hoist/envelope.js';\nimport { SentryError } from '../utils-hoist/error.js';\nimport { logger } from '../utils-hoist/logger.js';\nimport { makePromiseBuffer } from '../utils-hoist/promisebuffer.js';\nimport { isRateLimited, updateRateLimits } from '../utils-hoist/ratelimit.js';\nimport { resolvedSyncPromise } from '../utils-hoist/syncpromise.js';\n\nconst DEFAULT_TRANSPORT_BUFFER_SIZE = 64;\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(\n    options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE,\n  ),\n) {\n  let rateLimits = {};\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 dataCategory = envelopeItemTypeToDataCategory(type);\n      if (isRateLimited(rateLimits, dataCategory)) {\n        const event = getEventForEnvelopeItem(item, type);\n        options.recordDroppedEvent('ratelimit_backoff', dataCategory, event);\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    const filteredEnvelope = createEnvelope(envelope[0], filteredEnvelopeItems );\n\n    // Creates client report for each item in an envelope\n    const recordEnvelopeLoss = (reason) => {\n      forEachEnvelopeItem(filteredEnvelope, (item, type) => {\n        const event = getEventForEnvelopeItem(item, type);\n        options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type), event);\n      });\n    };\n\n    const requestTask = () =>\n      makeRequest({ body: serializeEnvelope(filteredEnvelope) }).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            DEBUG_BUILD && logger.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);\n          }\n\n          rateLimits = updateRateLimits(rateLimits, response);\n          return response;\n        },\n        error => {\n          recordEnvelopeLoss('network_error');\n          throw error;\n        },\n      );\n\n    return buffer.add(requestTask).then(\n      result => result,\n      error => {\n        if (error instanceof SentryError) {\n          DEBUG_BUILD && 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\nfunction getEventForEnvelopeItem(item, type) {\n  if (type !== 'event' && type !== 'transaction') {\n    return undefined;\n  }\n\n  return Array.isArray(item) ? (item )[1] : undefined;\n}\n\nexport { DEFAULT_TRANSPORT_BUFFER_SIZE, createTransport };\n//# sourceMappingURL=base.js.map\n","import { getEnvelopeEndpointWithUrlEncodedAuth } from '../api.js';\nimport { dsnFromString } from '../utils-hoist/dsn.js';\nimport { createEnvelope, forEachEnvelopeItem } from '../utils-hoist/envelope.js';\n\n/**\n * Gets an event from an envelope.\n *\n * This is only exported for use in the tests\n */\nfunction eventFromEnvelope(env, types) {\n  let event;\n\n  forEachEnvelopeItem(env, (item, type) => {\n    if (types.includes(type)) {\n      event = Array.isArray(item) ? (item )[1] : undefined;\n    }\n    // bail out if we found an event\n    return !!event;\n  });\n\n  return event;\n}\n\n/**\n * Creates a transport that overrides the release on all events.\n */\nfunction makeOverrideReleaseTransport(\n  createTransport,\n  release,\n) {\n  return options => {\n    const transport = createTransport(options);\n\n    return {\n      ...transport,\n      send: async (envelope) => {\n        const event = eventFromEnvelope(envelope, ['event', 'transaction', 'profile', 'replay_event']);\n\n        if (event) {\n          event.release = release;\n        }\n        return transport.send(envelope);\n      },\n    };\n  };\n}\n\n/** Overrides the DSN in the envelope header  */\nfunction overrideDsn(envelope, dsn) {\n  return createEnvelope(\n    dsn\n      ? {\n          ...envelope[0],\n          dsn,\n        }\n      : envelope[0],\n    envelope[1],\n  );\n}\n\n/**\n * Creates a transport that can send events to different DSNs depending on the envelope contents.\n */\nfunction makeMultiplexedTransport(\n  createTransport,\n  matcher,\n) {\n  return options => {\n    const fallbackTransport = createTransport(options);\n    const otherTransports = new Map();\n\n    function getTransport(dsn, release) {\n      // We create a transport for every unique dsn/release combination as there may be code from multiple releases in\n      // use at the same time\n      const key = release ? `${dsn}:${release}` : dsn;\n\n      let transport = otherTransports.get(key);\n\n      if (!transport) {\n        const validatedDsn = dsnFromString(dsn);\n        if (!validatedDsn) {\n          return undefined;\n        }\n        const url = getEnvelopeEndpointWithUrlEncodedAuth(validatedDsn, options.tunnel);\n\n        transport = release\n          ? makeOverrideReleaseTransport(createTransport, release)({ ...options, url })\n          : createTransport({ ...options, url });\n\n        otherTransports.set(key, transport);\n      }\n\n      return [dsn, transport];\n    }\n\n    async function send(envelope) {\n      function getEvent(types) {\n        const eventTypes = types && types.length ? types : ['event'];\n        return eventFromEnvelope(envelope, eventTypes);\n      }\n\n      const transports = matcher({ envelope, getEvent })\n        .map(result => {\n          if (typeof result === 'string') {\n            return getTransport(result, undefined);\n          } else {\n            return getTransport(result.dsn, result.release);\n          }\n        })\n        .filter((t) => !!t);\n\n      // If we have no transports to send to, use the fallback transport\n      // Don't override the DSN in the header for the fallback transport. '' is falsy\n      const transportsWithFallback = transports.length ? transports : [['', fallbackTransport]];\n\n      const results = (await Promise.all(\n        transportsWithFallback.map(([dsn, transport]) => transport.send(overrideDsn(envelope, dsn))),\n      )) ;\n\n      return results[0];\n    }\n\n    async function flush(timeout) {\n      const allTransports = [...otherTransports.values(), fallbackTransport];\n      const results = await Promise.all(allTransports.map(transport => transport.flush(timeout)));\n      return results.every(r => r);\n    }\n\n    return {\n      send,\n      flush,\n    };\n  };\n}\n\nexport { eventFromEnvelope, makeMultiplexedTransport };\n//# sourceMappingURL=multiplexed.js.map\n","import { DEBUG_BUILD } from '../debug-build.js';\nimport { envelopeContainsItemType } from '../utils-hoist/envelope.js';\nimport { logger } from '../utils-hoist/logger.js';\nimport { parseRetryAfterHeader } from '../utils-hoist/ratelimit.js';\n\nconst MIN_DELAY = 100; // 100 ms\nconst START_DELAY = 5000; // 5 seconds\nconst MAX_DELAY = 3.6e6; // 1 hour\n\n/**\n * Wraps a transport and stores and retries events when they fail to send.\n *\n * @param createTransport The transport to wrap.\n */\nfunction makeOfflineTransport(\n  createTransport,\n) {\n  function log(...args) {\n    DEBUG_BUILD && logger.info('[Offline]:', ...args);\n  }\n\n  return options => {\n    const transport = createTransport(options);\n\n    if (!options.createStore) {\n      throw new Error('No `createStore` function was provided');\n    }\n\n    const store = options.createStore(options);\n\n    let retryDelay = START_DELAY;\n    let flushTimer;\n\n    function shouldQueue(env, error, retryDelay) {\n      // We want to drop client reports because they can be generated when we retry sending events while offline.\n      if (envelopeContainsItemType(env, ['client_report'])) {\n        return false;\n      }\n\n      if (options.shouldStore) {\n        return options.shouldStore(env, error, retryDelay);\n      }\n\n      return true;\n    }\n\n    function flushIn(delay) {\n      if (flushTimer) {\n        clearTimeout(flushTimer );\n      }\n\n      flushTimer = setTimeout(async () => {\n        flushTimer = undefined;\n\n        const found = await store.shift();\n        if (found) {\n          log('Attempting to send previously queued event');\n\n          // We should to update the sent_at timestamp to the current time.\n          found[0].sent_at = new Date().toISOString();\n\n          void send(found, true).catch(e => {\n            log('Failed to retry sending', e);\n          });\n        }\n      }, delay) ;\n\n      // We need to unref the timer in node.js, otherwise the node process never exit.\n      if (typeof flushTimer !== 'number' && flushTimer.unref) {\n        flushTimer.unref();\n      }\n    }\n\n    function flushWithBackOff() {\n      if (flushTimer) {\n        return;\n      }\n\n      flushIn(retryDelay);\n\n      retryDelay = Math.min(retryDelay * 2, MAX_DELAY);\n    }\n\n    async function send(envelope, isRetry = false) {\n      // We queue all replay envelopes to avoid multiple replay envelopes being sent at the same time. If one fails, we\n      // need to retry them in order.\n      if (!isRetry && envelopeContainsItemType(envelope, ['replay_event', 'replay_recording'])) {\n        await store.push(envelope);\n        flushIn(MIN_DELAY);\n        return {};\n      }\n\n      try {\n        const result = await transport.send(envelope);\n\n        let delay = MIN_DELAY;\n\n        if (result) {\n          // If there's a retry-after header, use that as the next delay.\n          if (result.headers && result.headers['retry-after']) {\n            delay = parseRetryAfterHeader(result.headers['retry-after']);\n          } else if (result.headers && result.headers['x-sentry-rate-limits']) {\n            delay = 60000; // 60 seconds\n          } // If we have a server error, return now so we don't flush the queue.\n          else if ((result.statusCode || 0) >= 400) {\n            return result;\n          }\n        }\n\n        flushIn(delay);\n        retryDelay = START_DELAY;\n        return result;\n      } catch (e) {\n        if (await shouldQueue(envelope, e , retryDelay)) {\n          // If this envelope was a retry, we want to add it to the front of the queue so it's retried again first.\n          if (isRetry) {\n            await store.unshift(envelope);\n          } else {\n            await store.push(envelope);\n          }\n          flushWithBackOff();\n          log('Error sending. Event queued.', e );\n          return {};\n        } else {\n          throw e;\n        }\n      }\n    }\n\n    if (options.flushAtStartup) {\n      flushWithBackOff();\n    }\n\n    return {\n      send,\n      flush: t => transport.flush(t),\n    };\n  };\n}\n\nexport { MIN_DELAY, START_DELAY, makeOfflineTransport };\n//# sourceMappingURL=offline.js.map\n","import { isInstanceOf } from './is.js';\nimport { truncate } from './string.js';\n\n/**\n * Creates exceptions inside `event.exception.values` for errors that are nested on properties based on the `key` parameter.\n */\nfunction applyAggregateErrorsToEvent(\n  exceptionFromErrorImplementation,\n  parser,\n  maxValueLimit = 250,\n  key,\n  limit,\n  event,\n  hint,\n) {\n  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n    return;\n  }\n\n  // Generally speaking the last item in `event.exception.values` is the exception originating from the original Error\n  const originalException =\n    event.exception.values.length > 0 ? event.exception.values[event.exception.values.length - 1] : undefined;\n\n  // We only create exception grouping if there is an exception in the event.\n  if (originalException) {\n    event.exception.values = truncateAggregateExceptions(\n      aggregateExceptionsFromError(\n        exceptionFromErrorImplementation,\n        parser,\n        limit,\n        hint.originalException ,\n        key,\n        event.exception.values,\n        originalException,\n        0,\n      ),\n      maxValueLimit,\n    );\n  }\n}\n\nfunction aggregateExceptionsFromError(\n  exceptionFromErrorImplementation,\n  parser,\n  limit,\n  error,\n  key,\n  prevExceptions,\n  exception,\n  exceptionId,\n) {\n  if (prevExceptions.length >= limit + 1) {\n    return prevExceptions;\n  }\n\n  let newExceptions = [...prevExceptions];\n\n  // Recursively call this function in order to walk down a chain of errors\n  if (isInstanceOf(error[key], Error)) {\n    applyExceptionGroupFieldsForParentException(exception, exceptionId);\n    const newException = exceptionFromErrorImplementation(parser, error[key]);\n    const newExceptionId = newExceptions.length;\n    applyExceptionGroupFieldsForChildException(newException, key, newExceptionId, exceptionId);\n    newExceptions = aggregateExceptionsFromError(\n      exceptionFromErrorImplementation,\n      parser,\n      limit,\n      error[key],\n      key,\n      [newException, ...newExceptions],\n      newException,\n      newExceptionId,\n    );\n  }\n\n  // This will create exception grouping for AggregateErrors\n  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError\n  if (Array.isArray(error.errors)) {\n    error.errors.forEach((childError, i) => {\n      if (isInstanceOf(childError, Error)) {\n        applyExceptionGroupFieldsForParentException(exception, exceptionId);\n        const newException = exceptionFromErrorImplementation(parser, childError);\n        const newExceptionId = newExceptions.length;\n        applyExceptionGroupFieldsForChildException(newException, `errors[${i}]`, newExceptionId, exceptionId);\n        newExceptions = aggregateExceptionsFromError(\n          exceptionFromErrorImplementation,\n          parser,\n          limit,\n          childError,\n          key,\n          [newException, ...newExceptions],\n          newException,\n          newExceptionId,\n        );\n      }\n    });\n  }\n\n  return newExceptions;\n}\n\nfunction applyExceptionGroupFieldsForParentException(exception, exceptionId) {\n  // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.\n  exception.mechanism = exception.mechanism || { type: 'generic', handled: true };\n\n  exception.mechanism = {\n    ...exception.mechanism,\n    ...(exception.type === 'AggregateError' && { is_exception_group: true }),\n    exception_id: exceptionId,\n  };\n}\n\nfunction applyExceptionGroupFieldsForChildException(\n  exception,\n  source,\n  exceptionId,\n  parentId,\n) {\n  // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.\n  exception.mechanism = exception.mechanism || { type: 'generic', handled: true };\n\n  exception.mechanism = {\n    ...exception.mechanism,\n    type: 'chained',\n    source,\n    exception_id: exceptionId,\n    parent_id: parentId,\n  };\n}\n\n/**\n * Truncate the message (exception.value) of all exceptions in the event.\n * Because this event processor is ran after `applyClientOptions`,\n * we need to truncate the message of the added exceptions here.\n */\nfunction truncateAggregateExceptions(exceptions, maxValueLength) {\n  return exceptions.map(exception => {\n    if (exception.value) {\n      exception.value = truncate(exception.value, maxValueLength);\n    }\n    return exception;\n  });\n}\n\nexport { applyAggregateErrorsToEvent };\n//# sourceMappingURL=aggregate-errors.js.map\n","import { DEBUG_BUILD } from './debug-build.js';\nimport { isString } from './is.js';\nimport { logger } from './logger.js';\n\n/**\n * @deprecated Use a `\"baggage\"` string directly\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  const baggageObject = parseBaggageHeader(baggageHeader);\n\n  if (!baggageObject) {\n    return undefined;\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  if (!dynamicSamplingContext) {\n    return undefined;\n  }\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 * Take a baggage header and parse it into an object.\n */\nfunction parseBaggageHeader(\n  baggageHeader,\n) {\n  if (!baggageHeader || (!isString(baggageHeader) && !Array.isArray(baggageHeader))) {\n    return undefined;\n  }\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    return baggageHeader.reduce((acc, curr) => {\n      const currBaggageObject = baggageHeaderToObject(curr);\n      Object.entries(currBaggageObject).forEach(([key, value]) => {\n        acc[key] = value;\n      });\n      return acc;\n    }, {});\n  }\n\n  return baggageHeaderToObject(baggageHeader);\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      if (key && value) {\n        acc[key] = value;\n      }\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      DEBUG_BUILD &&\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, parseBaggageHeader };\n//# sourceMappingURL=baggage.js.map\n","/**\n * Determine a breadcrumb's log level (only `warning` or `error`) based on an HTTP status code.\n */\nfunction getBreadcrumbLogLevelFromHttpStatusCode(statusCode) {\n  // NOTE: undefined defaults to 'info' in Sentry\n  if (statusCode === undefined) {\n    return undefined;\n  } else if (statusCode >= 400 && statusCode < 500) {\n    return 'warning';\n  } else if (statusCode >= 500) {\n    return 'error';\n  } else {\n    return undefined;\n  }\n}\n\nexport { getBreadcrumbLogLevelFromHttpStatusCode };\n//# sourceMappingURL=breadcrumb-log-level.js.map\n","import { isString } from './is.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n\nconst WINDOW = GLOBAL_OBJ ;\n\nconst DEFAULT_MAX_STRING_LENGTH = 80;\n\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction htmlTreeAsString(\n  elem,\n  options = {},\n) {\n  if (!elem) {\n    return '<unknown>';\n  }\n\n  // try/catch both:\n  // - accessing event.target (see getsentry/raven-js#838, #768)\n  // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n  // - can throw an exception in some circumstances.\n  try {\n    let currentElem = elem ;\n    const MAX_TRAVERSE_HEIGHT = 5;\n    const out = [];\n    let height = 0;\n    let len = 0;\n    const separator = ' > ';\n    const sepLength = separator.length;\n    let nextStr;\n    const keyAttrs = Array.isArray(options) ? options : options.keyAttrs;\n    const maxStringLength = (!Array.isArray(options) && options.maxStringLength) || DEFAULT_MAX_STRING_LENGTH;\n\n    while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n      nextStr = _htmlElementAsString(currentElem, keyAttrs);\n      // bail out if\n      // - nextStr is the 'html' element\n      // - the length of the string that would be created exceeds maxStringLength\n      //   (ignore this limit if we are on the first iteration)\n      if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= maxStringLength)) {\n        break;\n      }\n\n      out.push(nextStr);\n\n      len += nextStr.length;\n      currentElem = currentElem.parentNode;\n    }\n\n    return out.reverse().join(separator);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction _htmlElementAsString(el, keyAttrs) {\n  const elem = el\n\n;\n\n  const out = [];\n\n  if (!elem || !elem.tagName) {\n    return '';\n  }\n\n  // @ts-expect-error WINDOW has HTMLElement\n  if (WINDOW.HTMLElement) {\n    // If using the component name annotation plugin, this value may be available on the DOM node\n    if (elem instanceof HTMLElement && elem.dataset) {\n      if (elem.dataset['sentryComponent']) {\n        return elem.dataset['sentryComponent'];\n      }\n      if (elem.dataset['sentryElement']) {\n        return elem.dataset['sentryElement'];\n      }\n    }\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    const className = elem.className;\n    if (className && isString(className)) {\n      const classes = className.split(/\\s+/);\n      for (const c of classes) {\n        out.push(`.${c}`);\n      }\n    }\n  }\n  const allowedAttrs = ['aria-label', 'type', 'name', 'title', 'alt'];\n  for (const k of allowedAttrs) {\n    const attr = elem.getAttribute(k);\n    if (attr) {\n      out.push(`[${k}=\"${attr}\"]`);\n    }\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 existence 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\n/**\n * Given a DOM element, traverses up the tree until it finds the first ancestor node\n * that has the `data-sentry-component` or `data-sentry-element` attribute with `data-sentry-component` taking\n * precedence. This attribute is added at build-time by projects that have the component name annotation plugin installed.\n *\n * @returns a string representation of the component for the provided DOM element, or `null` if not found\n */\nfunction getComponentName(elem) {\n  // @ts-expect-error WINDOW has HTMLElement\n  if (!WINDOW.HTMLElement) {\n    return null;\n  }\n\n  let currentElem = elem ;\n  const MAX_TRAVERSE_HEIGHT = 5;\n  for (let i = 0; i < MAX_TRAVERSE_HEIGHT; i++) {\n    if (!currentElem) {\n      return null;\n    }\n\n    if (currentElem instanceof HTMLElement) {\n      if (currentElem.dataset['sentryComponent']) {\n        return currentElem.dataset['sentryComponent'];\n      }\n      if (currentElem.dataset['sentryElement']) {\n        return currentElem.dataset['sentryElement'];\n      }\n    }\n\n    currentElem = currentElem.parentNode;\n  }\n\n  return null;\n}\n\nexport { getComponentName, getDomElement, getLocationHref, htmlTreeAsString };\n//# sourceMappingURL=browser.js.map\n","// https://github.com/alangpierce/sucrase/tree/265887868966917f3b924ce38dfad01fbab1329f\n//\n// The MIT License (MIT)\n//\n// Copyright (c) 2012-2018 various contributors (see AUTHORS)\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 all\n// 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 THE\n// SOFTWARE.\n\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","/**\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 { 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","/**\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 { GLOBAL_OBJ } from './worldwide.js';\n\nlet parsedStackResults;\nlet lastKeysCount;\nlet cachedFilenameDebugIds;\n\n/**\n * Returns a map of filenames to debug identifiers.\n */\nfunction getFilenameToDebugIdMap(stackParser) {\n  const debugIdMap = GLOBAL_OBJ._sentryDebugIds;\n  if (!debugIdMap) {\n    return {};\n  }\n\n  const debugIdKeys = Object.keys(debugIdMap);\n\n  // If the count of registered globals hasn't changed since the last call, we\n  // can just return the cached result.\n  if (cachedFilenameDebugIds && debugIdKeys.length === lastKeysCount) {\n    return cachedFilenameDebugIds;\n  }\n\n  lastKeysCount = debugIdKeys.length;\n\n  // Build a map of filename -> debug_id.\n  cachedFilenameDebugIds = debugIdKeys.reduce((acc, stackKey) => {\n    if (!parsedStackResults) {\n      parsedStackResults = {};\n    }\n\n    const result = parsedStackResults[stackKey];\n\n    if (result) {\n      acc[result[0]] = result[1];\n    } else {\n      const parsedStack = stackParser(stackKey);\n\n      for (let i = parsedStack.length - 1; i >= 0; i--) {\n        const stackFrame = parsedStack[i];\n        const filename = stackFrame && stackFrame.filename;\n        const debugId = debugIdMap[stackKey];\n\n        if (filename && debugId) {\n          acc[filename] = debugId;\n          parsedStackResults[stackKey] = [filename, debugId];\n          break;\n        }\n      }\n    }\n\n    return acc;\n  }, {});\n\n  return cachedFilenameDebugIds;\n}\n\n/**\n * Returns a list of debug images for the given resources.\n */\nfunction getDebugImagesForResources(\n  stackParser,\n  resource_paths,\n) {\n  const filenameDebugIdMap = getFilenameToDebugIdMap(stackParser);\n\n  if (!filenameDebugIdMap) {\n    return [];\n  }\n\n  const images = [];\n  for (const path of resource_paths) {\n    if (path && filenameDebugIdMap[path]) {\n      images.push({\n        type: 'sourcemap',\n        code_file: path,\n        debug_id: filenameDebugIdMap[path] ,\n      });\n    }\n  }\n\n  return images;\n}\n\nexport { getDebugImagesForResources, getFilenameToDebugIdMap };\n//# sourceMappingURL=debug-ids.js.map\n","import { DEBUG_BUILD } from './debug-build.js';\nimport { consoleSandbox, logger } from './logger.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 or undefined if @param str is not a valid DSN string\n */\nfunction dsnFromString(str) {\n  const match = DSN_REGEX.exec(str);\n\n  if (!match) {\n    // This should be logged to the console\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.error(`Invalid Sentry Dsn: ${str}`);\n    });\n    return undefined;\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 (!DEBUG_BUILD) {\n    return true;\n  }\n\n  const { port, projectId, protocol } = dsn;\n\n  const requiredComponents = ['protocol', 'publicKey', 'host', 'projectId'];\n  const hasMissingRequiredComponent = requiredComponents.find(component => {\n    if (!dsn[component]) {\n      logger.error(`Invalid Sentry Dsn: ${component} missing`);\n      return true;\n    }\n    return false;\n  });\n\n  if (hasMissingRequiredComponent) {\n    return false;\n  }\n\n  if (!projectId.match(/^\\d+$/)) {\n    logger.error(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);\n    return false;\n  }\n\n  if (!isValidProtocol(protocol)) {\n    logger.error(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);\n    return false;\n  }\n\n  if (port && isNaN(parseInt(port, 10))) {\n    logger.error(`Invalid Sentry Dsn: Invalid port ${port}`);\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Creates a valid Sentry Dsn object, identifying a Sentry instance and project.\n * @returns a valid DsnComponents object or `undefined` if @param from is an invalid DSN source\n */\nfunction makeDsn(from) {\n  const components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);\n  if (!components || !validateDsn(components)) {\n    return undefined;\n  }\n  return components;\n}\n\nexport { dsnFromString, dsnToString, makeDsn };\n//# sourceMappingURL=dsn.js.map\n","/*\n * This module exists for optimizations in the build process through rollup and terser.  We define some global\n * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these\n * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will\n * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to\n * `logger` and preventing node-related code from appearing in browser bundles.\n *\n * Attention:\n * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by\n * users. These flags should live in their respective packages, as we identified user tooling (specifically webpack)\n * having issues tree-shaking these constants across package boundaries.\n * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want\n * users to be able to shake away expressions that it guards.\n */\n\n/**\n * Figures out if we're building a browser bundle.\n *\n * @returns true if this is a browser bundle build.\n */\nfunction isBrowserBundle() {\n  return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;\n}\n\n/**\n * Get source of SDK.\n */\nfunction getSDKSource() {\n  // This comment is used to identify this line in the CDN bundle build step and replace this with \"return 'cdn';\"\n  /* __SENTRY_SDK_SOURCE__ */ return 'npm';\n}\n\nexport { getSDKSource, isBrowserBundle };\n//# sourceMappingURL=env.js.map\n","import { dsnToString } from './dsn.js';\nimport { normalize } from './normalize.js';\nimport { dropUndefinedKeys } from './object.js';\nimport { GLOBAL_OBJ } from './worldwide.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 *\n * If the callback returns true, the rest of the items will be skipped.\n */\nfunction forEachEnvelopeItem(\n  envelope,\n  callback,\n) {\n  const envelopeItems = envelope[1];\n\n  for (const envelopeItem of envelopeItems) {\n    const envelopeItemType = envelopeItem[0].type;\n    const result = callback(envelopeItem, envelopeItemType);\n\n    if (result) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Returns true if the envelope contains any of the given envelope item types\n */\nfunction envelopeContainsItemType(envelope, types) {\n  return forEachEnvelopeItem(envelope, (_, type) => types.includes(type));\n}\n\n/**\n * Encode a string to UTF8 array.\n */\nfunction encodeUTF8(input) {\n  return GLOBAL_OBJ.__SENTRY__ && GLOBAL_OBJ.__SENTRY__.encodePolyfill\n    ? GLOBAL_OBJ.__SENTRY__.encodePolyfill(input)\n    : new TextEncoder().encode(input);\n}\n\n/**\n * Decode a UTF8 array to string.\n */\nfunction decodeUTF8(input) {\n  return GLOBAL_OBJ.__SENTRY__ && GLOBAL_OBJ.__SENTRY__.decodePolyfill\n    ? GLOBAL_OBJ.__SENTRY__.decodePolyfill(input)\n    : new TextDecoder().decode(input);\n}\n\n/**\n * Serializes an envelope.\n */\nfunction serializeEnvelope(envelope) {\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), next];\n    } else {\n      parts.push(typeof next === 'string' ? encodeUTF8(next) : 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.stringify()` 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 * Parses an envelope\n */\nfunction parseEnvelope(env) {\n  let buffer = typeof env === 'string' ? encodeUTF8(env) : env;\n\n  function readBinary(length) {\n    const bin = buffer.subarray(0, length);\n    // Replace the buffer with the remaining data excluding trailing newline\n    buffer = buffer.subarray(length + 1);\n    return bin;\n  }\n\n  function readJson() {\n    let i = buffer.indexOf(0xa);\n    // If we couldn't find a newline, we must have found the end of the buffer\n    if (i < 0) {\n      i = buffer.length;\n    }\n\n    return JSON.parse(decodeUTF8(readBinary(i))) ;\n  }\n\n  const envelopeHeader = readJson();\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const items = [];\n\n  while (buffer.length) {\n    const itemHeader = readJson();\n    const binaryLength = typeof itemHeader.length === 'number' ? itemHeader.length : undefined;\n\n    items.push([itemHeader, binaryLength ? readBinary(binaryLength) : readJson()]);\n  }\n\n  return [envelopeHeader, items];\n}\n\n/**\n * Creates envelope item for a single span\n */\nfunction createSpanEnvelopeItem(spanJson) {\n  const spanHeaders = {\n    type: 'span',\n  };\n\n  return [spanHeaders, spanJson];\n}\n\n/**\n * Creates attachment envelope items\n */\nfunction createAttachmentEnvelopeItem(attachment) {\n  const buffer = typeof attachment.data === 'string' ? encodeUTF8(attachment.data) : 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  profile: 'profile',\n  profile_chunk: 'profile',\n  replay_event: 'replay',\n  replay_recording: 'replay',\n  check_in: 'monitor',\n  feedback: 'feedback',\n  span: 'span',\n  statsd: 'metric_bucket',\n  raw_security: 'security',\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\n/** Extracts the minimal SDK info from the metadata or an events */\nfunction getSdkMetadataForEnvelopeHeader(metadataOrEvent) {\n  if (!metadataOrEvent || !metadataOrEvent.sdk) {\n    return;\n  }\n  const { name, version } = metadataOrEvent.sdk;\n  return { name, version };\n}\n\n/**\n * Creates event envelope headers, based on event, sdk info and tunnel\n * Note: This function was extracted from the core package to make it available in Replay\n */\nfunction createEventEnvelopeHeaders(\n  event,\n  sdkInfo,\n  tunnel,\n  dsn,\n) {\n  const dynamicSamplingContext = event.sdkProcessingMetadata && event.sdkProcessingMetadata.dynamicSamplingContext;\n  return {\n    event_id: event.event_id ,\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && dsn && { dsn: dsnToString(dsn) }),\n    ...(dynamicSamplingContext && {\n      trace: dropUndefinedKeys({ ...dynamicSamplingContext }),\n    }),\n  };\n}\n\nexport { addItemToEnvelope, createAttachmentEnvelopeItem, createEnvelope, createEventEnvelopeHeaders, createSpanEnvelopeItem, envelopeContainsItemType, envelopeItemTypeToDataCategory, forEachEnvelopeItem, getSdkMetadataForEnvelopeHeader, parseEnvelope, 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(\n     message,\n    logLevel = 'warn',\n  ) {\n    super(message);this.message = message;\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 { CONSOLE_LEVELS, originalConsoleMethods } from '../logger.js';\nimport { fill } from '../object.js';\nimport { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './handlers.js';\n\n/**\n * Add an instrumentation handler for when a console.xxx method is called.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addConsoleInstrumentationHandler(handler) {\n  const type = 'console';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentConsole);\n}\n\nfunction instrumentConsole() {\n  if (!('console' in GLOBAL_OBJ)) {\n    return;\n  }\n\n  CONSOLE_LEVELS.forEach(function (level) {\n    if (!(level in GLOBAL_OBJ.console)) {\n      return;\n    }\n\n    fill(GLOBAL_OBJ.console, level, function (originalConsoleMethod) {\n      originalConsoleMethods[level] = originalConsoleMethod;\n\n      return function (...args) {\n        const handlerData = { args, level };\n        triggerHandlers('console', handlerData);\n\n        const log = originalConsoleMethods[level];\n        log && log.apply(GLOBAL_OBJ.console, args);\n      };\n    });\n  });\n}\n\nexport { addConsoleInstrumentationHandler };\n//# sourceMappingURL=console.js.map\n","import { isError } from '../is.js';\nimport { fill, addNonEnumerableProperty } from '../object.js';\nimport { supportsNativeFetch } from '../supports.js';\nimport { timestampInSeconds } from '../time.js';\nimport { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './handlers.js';\n\n/**\n * Add an instrumentation handler for when a fetch request happens.\n * The handler function is called once when the request starts and once when it ends,\n * which can be identified by checking if it has an `endTimestamp`.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addFetchInstrumentationHandler(\n  handler,\n  skipNativeFetchCheck,\n) {\n  const type = 'fetch';\n  addHandler(type, handler);\n  maybeInstrument(type, () => instrumentFetch(undefined, skipNativeFetchCheck));\n}\n\n/**\n * Add an instrumentation handler for long-lived fetch requests, like consuming server-sent events (SSE) via fetch.\n * The handler will resolve the request body and emit the actual `endTimestamp`, so that the\n * span can be updated accordingly.\n *\n * Only used internally\n * @hidden\n */\nfunction addFetchEndInstrumentationHandler(handler) {\n  const type = 'fetch-body-resolved';\n  addHandler(type, handler);\n  maybeInstrument(type, () => instrumentFetch(streamHandler));\n}\n\nfunction instrumentFetch(onFetchResolved, skipNativeFetchCheck = false) {\n  if (skipNativeFetchCheck && !supportsNativeFetch()) {\n    return;\n  }\n\n  fill(GLOBAL_OBJ, 'fetch', function (originalFetch) {\n    return function (...args) {\n      // We capture the error right here and not in the Promise error callback because Safari (and probably other\n      // browsers too) will wipe the stack trace up to this point, only leaving us with this file which is useless.\n\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n      //       it means the error, that was caused by your fetch call did not\n      //       have a stack trace, so the SDK backfilled the stack trace so\n      //       you can see which fetch call failed.\n      const virtualError = new Error();\n\n      const { method, url } = parseFetchArgs(args);\n      const handlerData = {\n        args,\n        fetchData: {\n          method,\n          url,\n        },\n        startTimestamp: timestampInSeconds() * 1000,\n        // // Adding the error to be able to fingerprint the failed fetch event in HttpClient instrumentation\n        virtualError,\n      };\n\n      // if there is no callback, fetch is instrumented directly\n      if (!onFetchResolved) {\n        triggerHandlers('fetch', {\n          ...handlerData,\n        });\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      return originalFetch.apply(GLOBAL_OBJ, args).then(\n        async (response) => {\n          if (onFetchResolved) {\n            onFetchResolved(response);\n          } else {\n            triggerHandlers('fetch', {\n              ...handlerData,\n              endTimestamp: timestampInSeconds() * 1000,\n              response,\n            });\n          }\n\n          return response;\n        },\n        (error) => {\n          triggerHandlers('fetch', {\n            ...handlerData,\n            endTimestamp: timestampInSeconds() * 1000,\n            error,\n          });\n\n          if (isError(error) && error.stack === undefined) {\n            // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n            //       it means the error, that was caused by your fetch call did not\n            //       have a stack trace, so the SDK backfilled the stack trace so\n            //       you can see which fetch call failed.\n            error.stack = virtualError.stack;\n            addNonEnumerableProperty(error, 'framesToPop', 1);\n          }\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\nasync function resolveResponse(res, onFinishedResolving) {\n  if (res && res.body) {\n    const body = res.body;\n    const responseReader = body.getReader();\n\n    // Define a maximum duration after which we just cancel\n    const maxFetchDurationTimeout = setTimeout(\n      () => {\n        body.cancel().then(null, () => {\n          // noop\n        });\n      },\n      90 * 1000, // 90s\n    );\n\n    let readingActive = true;\n    while (readingActive) {\n      let chunkTimeout;\n      try {\n        // abort reading if read op takes more than 5s\n        chunkTimeout = setTimeout(() => {\n          body.cancel().then(null, () => {\n            // noop on error\n          });\n        }, 5000);\n\n        // This .read() call will reject/throw when we abort due to timeouts through `body.cancel()`\n        const { done } = await responseReader.read();\n\n        clearTimeout(chunkTimeout);\n\n        if (done) {\n          onFinishedResolving();\n          readingActive = false;\n        }\n      } catch (error) {\n        readingActive = false;\n      } finally {\n        clearTimeout(chunkTimeout);\n      }\n    }\n\n    clearTimeout(maxFetchDurationTimeout);\n\n    responseReader.releaseLock();\n    body.cancel().then(null, () => {\n      // noop on error\n    });\n  }\n}\n\nfunction streamHandler(response) {\n  // clone response for awaiting stream\n  let clonedResponseForResolving;\n  try {\n    clonedResponseForResolving = response.clone();\n  } catch (e) {\n    return;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-floating-promises\n  resolveResponse(clonedResponseForResolving, () => {\n    triggerHandlers('fetch-body-resolved', {\n      endTimestamp: timestampInSeconds() * 1000,\n      response,\n    });\n  });\n}\n\nfunction hasProp(obj, prop) {\n  return !!obj && typeof obj === 'object' && !!(obj )[prop];\n}\n\nfunction getUrlFromResource(resource) {\n  if (typeof resource === 'string') {\n    return resource;\n  }\n\n  if (!resource) {\n    return '';\n  }\n\n  if (hasProp(resource, 'url')) {\n    return resource.url;\n  }\n\n  if (resource.toString) {\n    return resource.toString();\n  }\n\n  return '';\n}\n\n/**\n * Parses the fetch arguments to find the used Http method and the url of the request.\n * Exported for tests only.\n */\nfunction parseFetchArgs(fetchArgs) {\n  if (fetchArgs.length === 0) {\n    return { method: 'GET', url: '' };\n  }\n\n  if (fetchArgs.length === 2) {\n    const [url, options] = fetchArgs ;\n\n    return {\n      url: getUrlFromResource(url),\n      method: hasProp(options, 'method') ? String(options.method).toUpperCase() : 'GET',\n    };\n  }\n\n  const arg = fetchArgs[0];\n  return {\n    url: getUrlFromResource(arg ),\n    method: hasProp(arg, 'method') ? String(arg.method).toUpperCase() : 'GET',\n  };\n}\n\nexport { addFetchEndInstrumentationHandler, addFetchInstrumentationHandler, parseFetchArgs };\n//# sourceMappingURL=fetch.js.map\n","import { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './handlers.js';\n\nlet _oldOnErrorHandler = null;\n\n/**\n * Add an instrumentation handler for when an error is captured by the global error handler.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addGlobalErrorInstrumentationHandler(handler) {\n  const type = 'error';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentError);\n}\n\nfunction instrumentError() {\n  _oldOnErrorHandler = GLOBAL_OBJ.onerror;\n\n  // Note: The reason we are doing window.onerror instead of window.addEventListener('error')\n  // is that we are using this handler in the Loader Script, to handle buffered errors consistently\n  GLOBAL_OBJ.onerror = function (\n    msg,\n    url,\n    line,\n    column,\n    error,\n  ) {\n    const handlerData = {\n      column,\n      error,\n      line,\n      msg,\n      url,\n    };\n    triggerHandlers('error', handlerData);\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  GLOBAL_OBJ.onerror.__SENTRY_INSTRUMENTED__ = true;\n}\n\nexport { addGlobalErrorInstrumentationHandler };\n//# sourceMappingURL=globalError.js.map\n","import { GLOBAL_OBJ } from '../worldwide.js';\nimport { addHandler, maybeInstrument, triggerHandlers } from './handlers.js';\n\nlet _oldOnUnhandledRejectionHandler = null;\n\n/**\n * Add an instrumentation handler for when an unhandled promise rejection is captured.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addGlobalUnhandledRejectionInstrumentationHandler(\n  handler,\n) {\n  const type = 'unhandledrejection';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentUnhandledRejection);\n}\n\nfunction instrumentUnhandledRejection() {\n  _oldOnUnhandledRejectionHandler = GLOBAL_OBJ.onunhandledrejection;\n\n  // Note: The reason we are doing window.onunhandledrejection instead of window.addEventListener('unhandledrejection')\n  // is that we are using this handler in the Loader Script, to handle buffered rejections consistently\n  GLOBAL_OBJ.onunhandledrejection = function (e) {\n    const handlerData = e;\n    triggerHandlers('unhandledrejection', handlerData);\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  GLOBAL_OBJ.onunhandledrejection.__SENTRY_INSTRUMENTED__ = true;\n}\n\nexport { addGlobalUnhandledRejectionInstrumentationHandler };\n//# sourceMappingURL=globalUnhandledRejection.js.map\n","import { DEBUG_BUILD } from '../debug-build.js';\nimport { logger } from '../logger.js';\nimport { getFunctionName } from '../stacktrace.js';\n\n// We keep the handlers globally\nconst handlers = {};\nconst instrumented = {};\n\n/** Add a handler function. */\nfunction addHandler(type, handler) {\n  handlers[type] = handlers[type] || [];\n  (handlers[type] ).push(handler);\n}\n\n/**\n * Reset all instrumentation handlers.\n * This can be used by tests to ensure we have a clean slate of instrumentation handlers.\n */\nfunction resetInstrumentationHandlers() {\n  Object.keys(handlers).forEach(key => {\n    handlers[key ] = undefined;\n  });\n}\n\n/** Maybe run an instrumentation function, unless it was already called. */\nfunction maybeInstrument(type, instrumentFn) {\n  if (!instrumented[type]) {\n    instrumented[type] = true;\n    try {\n      instrumentFn();\n    } catch (e) {\n      DEBUG_BUILD && logger.error(`Error while instrumenting ${type}`, e);\n    }\n  }\n}\n\n/** Trigger handlers for a given instrumentation type. */\nfunction triggerHandlers(type, data) {\n  const typeHandlers = type && handlers[type];\n  if (!typeHandlers) {\n    return;\n  }\n\n  for (const handler of typeHandlers) {\n    try {\n      handler(data);\n    } catch (e) {\n      DEBUG_BUILD &&\n        logger.error(\n          `Error while triggering instrumentation handler.\\nType: ${type}\\nName: ${getFunctionName(handler)}\\nError:`,\n          e,\n        );\n    }\n  }\n}\n\nexport { addHandler, maybeInstrument, resetInstrumentationHandlers, triggerHandlers };\n//# sourceMappingURL=handlers.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    case '[object WebAssembly.Exception]':\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 string is parameterized\n * {@link isParameterizedString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isParameterizedString(wat) {\n  return (\n    typeof wat === 'object' &&\n    wat !== null &&\n    '__sentry_template_string__' in wat &&\n    '__sentry_template_values__' in wat\n  );\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 || isParameterizedString(wat) || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n\n/**\n * Checks whether given value's type is an object literal, or a class instance.\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's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nfunction isInstanceOf(wat, base) {\n  try {\n    return wat instanceof base;\n  } catch (_e) {\n    return false;\n  }\n}\n\n/**\n * Checks whether given value's type is a Vue ViewModel.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nfunction isVueViewModel(wat) {\n  // Not using Object.prototype.toString because in Vue 3 it would read the instance's Symbol(Symbol.toStringTag) property.\n  return !!(typeof wat === 'object' && wat !== null && ((wat ).__isVue || (wat )._isVue));\n}\n\nexport { isDOMError, isDOMException, isElement, isError, isErrorEvent, isEvent, isInstanceOf, isParameterizedString, isPlainObject, isPrimitive, isRegExp, isString, isSyntheticEvent, isThenable, isVueViewModel };\n//# sourceMappingURL=is.js.map\n","import { isNodeEnv } from './node.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n\n/**\n * Returns true if we are in the browser.\n */\nfunction isBrowser() {\n  // eslint-disable-next-line no-restricted-globals\n  return typeof window !== 'undefined' && (!isNodeEnv() || isElectronNodeRenderer());\n}\n\n// Electron renderers with nodeIntegration enabled are detected as Node.js so we specifically test for them\nfunction isElectronNodeRenderer() {\n  const process = (GLOBAL_OBJ ).process;\n  return !!process && process.type === 'renderer';\n}\n\nexport { isBrowser };\n//# sourceMappingURL=isBrowser.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/**\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 * @deprecated This function will be removed in the next major version.\n */\n// eslint-disable-next-line @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    // eslint-disable-next-line deprecation/deprecation\n    mod = dynamicRequire(module, moduleName);\n  } catch (e) {\n    // no-empty\n  }\n\n  if (!mod) {\n    try {\n      // eslint-disable-next-line deprecation/deprecation\n      const { cwd } = dynamicRequire(module, 'process');\n      // eslint-disable-next-line deprecation/deprecation\n      mod = dynamicRequire(module, `${cwd()}/node_modules/${moduleName}`) ;\n    } catch (e) {\n      // no-empty\n    }\n  }\n\n  return mod;\n}\n\nexport { dynamicRequire, isNodeEnv, loadModule };\n//# sourceMappingURL=node.js.map\n","import { DEBUG_BUILD } from './debug-build.js';\nimport { getGlobalSingleton, GLOBAL_OBJ } from './worldwide.js';\n\n/** Prefix for logging strings */\nconst PREFIX = 'Sentry Logger ';\n\nconst CONSOLE_LEVELS = [\n  'debug',\n  'info',\n  'warn',\n  'error',\n  'log',\n  'assert',\n  'trace',\n] ;\n\n/** This may be mutated by the console instrumentation. */\nconst originalConsoleMethods\n\n = {};\n\n/** JSDoc */\n\n/**\n * Temporarily disable sentry console instrumentations.\n *\n * @param callback The function to run against the original `console` messages\n * @returns The results of the callback\n */\nfunction consoleSandbox(callback) {\n  if (!('console' in GLOBAL_OBJ)) {\n    return callback();\n  }\n\n  const console = GLOBAL_OBJ.console ;\n  const wrappedFuncs = {};\n\n  const wrappedLevels = Object.keys(originalConsoleMethods) ;\n\n  // Restore all wrapped console methods\n  wrappedLevels.forEach(level => {\n    const originalConsoleMethod = originalConsoleMethods[level] ;\n    wrappedFuncs[level] = console[level] ;\n    console[level] = originalConsoleMethod;\n  });\n\n  try {\n    return callback();\n  } finally {\n    // Revert restoration to wrapped state\n    wrappedLevels.forEach(level => {\n      console[level] = wrappedFuncs[level] ;\n    });\n  }\n}\n\nfunction makeLogger() {\n  let enabled = false;\n  const logger = {\n    enable: () => {\n      enabled = true;\n    },\n    disable: () => {\n      enabled = false;\n    },\n    isEnabled: () => enabled,\n  };\n\n  if (DEBUG_BUILD) {\n    CONSOLE_LEVELS.forEach(name => {\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/**\n * This is a logger singleton which either logs things or no-ops if logging is not enabled.\n * The logger is a singleton on the carrier, to ensure that a consistent logger is used throughout the SDK.\n */\nconst logger = getGlobalSingleton('logger', makeLogger);\n\nexport { CONSOLE_LEVELS, consoleSandbox, logger, originalConsoleMethods };\n//# sourceMappingURL=logger.js.map\n","import { addNonEnumerableProperty } from './object.js';\nimport { snipLine } from './string.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nfunction uuid4() {\n  const gbl = GLOBAL_OBJ ;\n  const crypto = gbl.crypto || gbl.msCrypto;\n\n  let getRandomByte = () => Math.random() * 16;\n  try {\n    if (crypto && crypto.randomUUID) {\n      return crypto.randomUUID().replace(/-/g, '');\n    }\n    if (crypto && crypto.getRandomValues) {\n      getRandomByte = () => {\n        // crypto.getRandomValues might return undefined instead of the typed array\n        // in old Chromium versions (e.g. 23.0.1235.0 (151422))\n        // However, `typedArray` is still filled in-place.\n        // @see https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues#typedarray\n        const typedArray = new Uint8Array(1);\n        crypto.getRandomValues(typedArray);\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        return typedArray[0];\n      };\n    }\n  } catch (_) {\n    // some runtimes can crash invoking crypto\n    // https://github.com/getsentry/sentry-javascript/issues/8935\n  }\n\n  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n  // Concatenating the following numbers as strings results in '10000000100040008000100000000000'\n  return (([1e7] ) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>\n    // eslint-disable-next-line no-bitwise\n    ((c ) ^ ((getRandomByte() & 15) >> ((c ) / 4))).toString(16),\n  );\n}\n\nfunction getFirstException(event) {\n  return event.exception && event.exception.values ? event.exception.values[0] : undefined;\n}\n\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nfunction getEventDescription(event) {\n  const { message, event_id: eventId } = event;\n  if (message) {\n    return message;\n  }\n\n  const firstException = getFirstException(event);\n  if (firstException) {\n    if (firstException.type && firstException.value) {\n      return `${firstException.type}: ${firstException.value}`;\n    }\n    return firstException.type || firstException.value || eventId || '<unknown>';\n  }\n  return eventId || '<unknown>';\n}\n\n/**\n * Adds exception values, type and value to an synthetic Exception.\n * @param event The event to modify.\n * @param value Value of the exception.\n * @param type Type of the exception.\n * @hidden\n */\nfunction addExceptionTypeValue(event, value, type) {\n  const exception = (event.exception = event.exception || {});\n  const values = (exception.values = exception.values || []);\n  const firstException = (values[0] = values[0] || {});\n  if (!firstException.value) {\n    firstException.value = value || '';\n  }\n  if (!firstException.type) {\n    firstException.type = type || 'Error';\n  }\n}\n\n/**\n * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.\n *\n * @param event The event to modify.\n * @param newMechanism Mechanism data to add to the event.\n * @hidden\n */\nfunction addExceptionMechanism(event, newMechanism) {\n  const firstException = getFirstException(event);\n  if (!firstException) {\n    return;\n  }\n\n  const defaultMechanism = { type: 'generic', handled: true };\n  const currentMechanism = firstException.mechanism;\n  firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };\n\n  if (newMechanism && 'data' in newMechanism) {\n    const mergedData = { ...(currentMechanism && currentMechanism.data), ...newMechanism.data };\n    firstException.mechanism.data = mergedData;\n  }\n}\n\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nconst SEMVER_REGEXP =\n  /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n\n/**\n * Represents Semantic Versioning object\n */\n\nfunction _parseInt(input) {\n  return parseInt(input || '', 10);\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]);\n  const minor = _parseInt(match[2]);\n  const patch = _parseInt(match[3]);\n  return {\n    buildmetadata: match[5],\n    major: isNaN(major) ? undefined : major,\n    minor: isNaN(minor) ? undefined : minor,\n    patch: isNaN(patch) ? undefined : patch,\n    prerelease: match[4],\n  };\n}\n\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nfunction addContextToFrame(lines, frame, linesOfContext = 5) {\n  // When there is no line number in the frame, attaching context is nonsensical and will even break grouping\n  if (frame.lineno === undefined) {\n    return;\n  }\n\n  const maxLines = lines.length;\n  const sourceLine = Math.max(Math.min(maxLines - 1, frame.lineno - 1), 0);\n\n  frame.pre_context = lines\n    .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n    .map((line) => snipLine(line, 0));\n\n  // We guard here to ensure this is not larger than the existing number of lines\n  const lineIndex = Math.min(maxLines - 1, sourceLine);\n\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  frame.context_line = snipLine(lines[lineIndex], 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  if (isAlreadyCaptured(exception)) {\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\nfunction isAlreadyCaptured(exception) {\n  try {\n    return (exception ).__sentry_captured__;\n  } catch (e) {} // eslint-disable-line no-empty\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 *\n * @deprecated This function has been deprecated and will not be replaced.\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 { isVueViewModel, 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 normalized 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 = 100, 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  // eslint-disable-next-line deprecation/deprecation\n  memo = memoBuilder(),\n) {\n  const [memoize, unmemoize] = memo;\n\n  // Get the simple cases out of the way first\n  if (\n    value == null || // this matches null and undefined -> eqeq not eqeqeq\n    ['boolean', 'string'].includes(typeof value) ||\n    (typeof value === 'number' && Number.isFinite(value))\n  ) {\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 can set `__sentry_override_normalization_depth__` on an object to ensure that from there\n  // We keep a certain amount of depth.\n  // This should be used sparingly, e.g. we use it for the redux integration to ensure we get a certain amount of state.\n  const remainingDepth =\n    typeof (value )['__sentry_override_normalization_depth__'] === 'number'\n      ? ((value )['__sentry_override_normalization_depth__'] )\n      : depth;\n\n  // We're also done if we've reached the max depth\n  if (remainingDepth === 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, remainingDepth - 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, remainingDepth - 1, maxProperties, memo);\n\n    numAdded++;\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/* eslint-disable complexity */\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    if (isVueViewModel(value)) {\n      return '[VueViewModel]';\n    }\n\n    // React's SyntheticEvent thingy\n    if (isSyntheticEvent(value)) {\n      return '[SyntheticEvent]';\n    }\n\n    if (typeof value === 'number' && !Number.isFinite(value)) {\n      return `[${value}]`;\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    const objName = getConstructorName(value);\n\n    // Handle HTML Elements\n    if (/^HTML(\\w*)Element$/.test(objName)) {\n      return `[HTMLElement: ${objName}]`;\n    }\n\n    return `[object ${objName}]`;\n  } catch (err) {\n    return `**non-serializable** (${err})`;\n  }\n}\n/* eslint-enable complexity */\n\nfunction getConstructorName(value) {\n  const prototype = Object.getPrototypeOf(value);\n\n  return prototype ? prototype.constructor.name : 'null prototype';\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\n/**\n * Normalizes URLs in exceptions and stacktraces to a base path so Sentry can fingerprint\n * across platforms and working directory.\n *\n * @param url The URL to be normalized.\n * @param basePath The application base path.\n * @returns The normalized URL.\n */\nfunction normalizeUrlToBase(url, basePath) {\n  const escapedBase = basePath\n    // Backslash to forward\n    .replace(/\\\\/g, '/')\n    // Escape RegExp special characters\n    .replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&');\n\n  let newUrl = url;\n  try {\n    newUrl = decodeURI(url);\n  } catch (_Oo) {\n    // Sometime this breaks\n  }\n  return (\n    newUrl\n      .replace(/\\\\/g, '/')\n      .replace(/webpack:\\/?/g, '') // Remove intermediate base path\n      // eslint-disable-next-line @sentry-internal/sdk/no-regexp-constructor\n      .replace(new RegExp(`(file://)?/*${escapedBase}/*`, 'ig'), 'app:///')\n  );\n}\n\nexport { normalize, normalizeToSize, normalizeUrlToBase };\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 *\n * @deprecated This function is deprecated and will be removed in the next major version.\n */\n// TODO(v9): Move this function into normalize() directly\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 { DEBUG_BUILD } from './debug-build.js';\nimport { isError, isEvent, isInstanceOf, isElement, isPlainObject, isPrimitive } from './is.js';\nimport { logger } from './logger.js';\nimport { truncate } from './string.js';\n\n/**\n * Replace a method in an object with a wrapped version of itself.\n *\n * @param source An object that contains a method to be wrapped.\n * @param name The name of the method to be wrapped.\n * @param replacementFactory A higher-order function that takes the original version of the given method and returns a\n * wrapped version. Note: The function returned by `replacementFactory` needs to be a non-arrow function, in order to\n * preserve the correct value of `this`, and the original method must be called using `origMethod.call(this, <other\n * args>)` or `origMethod.apply(this, [<other args>])` (rather than being called directly), again to preserve `this`.\n * @returns void\n */\nfunction fill(source, name, replacementFactory) {\n  if (!(name in source)) {\n    return;\n  }\n\n  const original = source[name] ;\n  const wrapped = replacementFactory(original) ;\n\n  // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n  // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n  if (typeof wrapped === 'function') {\n    markFunctionWrapped(wrapped, original);\n  }\n\n  try {\n    source[name] = wrapped;\n  } catch (e) {\n    DEBUG_BUILD && logger.log(`Failed to replace method \"${name}\" in object`, source);\n  }\n}\n\n/**\n * Defines a non-enumerable property on the given object.\n *\n * @param obj The object on which to set the property\n * @param name The name of the property to be set\n * @param value The value to which to set the property\n */\nfunction addNonEnumerableProperty(obj, name, value) {\n  try {\n    Object.defineProperty(obj, name, {\n      // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it\n      value: value,\n      writable: true,\n      configurable: true,\n    });\n  } catch (o_O) {\n    DEBUG_BUILD && logger.log(`Failed to add non-enumerable property \"${name}\" to object`, obj);\n  }\n}\n\n/**\n * Remembers the original function on the wrapped function and\n * patches up the prototype.\n *\n * @param wrapped the wrapper function\n * @param original the original function that gets wrapped\n */\nfunction markFunctionWrapped(wrapped, original) {\n  try {\n    const proto = original.prototype || {};\n    wrapped.prototype = original.prototype = proto;\n    addNonEnumerableProperty(wrapped, '__sentry_original__', original);\n  } catch (o_O) {} // eslint-disable-line no-empty\n}\n\n/**\n * This extracts the original function if available.  See\n * `markFunctionWrapped` for more information.\n *\n * @param func the function to unwrap\n * @returns the unwrapped version of the function if available.\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\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 *\n * @deprecated This function is deprecated and will be removed in the next major version of the SDK.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction urlEncode(object) {\n  return Object.entries(object)\n    .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)\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 argument itself, when value is neither an Event nor\n *  an Error.\n */\nfunction convertToPlainObject(value)\n\n {\n  if (isError(value)) {\n    return {\n      message: value.message,\n      name: value.name,\n      stack: value.stack,\n      ...getOwnProperties(value),\n    };\n  } else if (isEvent(value)) {\n    const newObj\n\n = {\n      type: value.type,\n      target: serializeEventTarget(value.target),\n      currentTarget: serializeEventTarget(value.currentTarget),\n      ...getOwnProperties(value),\n    };\n\n    if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n      newObj.detail = value.detail;\n    }\n\n    return newObj;\n  } else {\n    return value;\n  }\n}\n\n/** Creates a string representation of the target of an `Event` object */\nfunction serializeEventTarget(target) {\n  try {\n    return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/** Filters out all but an object's own properties */\nfunction getOwnProperties(obj) {\n  if (typeof obj === 'object' && obj !== null) {\n    const extractedProps = {};\n    for (const property in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, property)) {\n        extractedProps[property] = (obj )[property];\n      }\n    }\n    return extractedProps;\n  } else {\n    return {};\n  }\n}\n\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\nfunction extractExceptionKeysForMessage(exception, maxLength = 40) {\n  const keys = Object.keys(convertToPlainObject(exception));\n  keys.sort();\n\n  const firstKey = keys[0];\n\n  if (!firstKey) {\n    return '[object has no keys]';\n  }\n\n  if (firstKey.length >= maxLength) {\n    return truncate(firstKey, 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 (isPojo(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.getOwnPropertyNames(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\nfunction isPojo(input) {\n  if (!isPlainObject(input)) {\n    return false;\n  }\n\n  try {\n    const name = (Object.getPrototypeOf(input) ).constructor.name;\n    return !name || name === 'Object';\n  } catch (e2) {\n    return true;\n  }\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    // this will catch both undefined and null\n    case wat == undefined:\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","// Slightly modified (no IE8 support, ES6) and transcribed to TypeScript\n// https://github.com/calvinmetcalf/rollup-plugin-node-builtins/blob/63ab8aacd013767445ca299e468d9a60a95328d7/src/es6/path.js\n//\n// Copyright Joyent, Inc.and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n/** JSDoc */\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  let up = 0;\n  for (let i = parts.length - 1; i >= 0; i--) {\n    const last = parts[i];\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n}\n\n// Split a filename into [root, dir, basename, ext], unix version\n// 'root' is just a slash, or nothing.\nconst splitPathRe = /^(\\S+:\\\\|\\/?)([\\s\\S]*?)((?:\\.{1,2}|[^/\\\\]+?|)(\\.[^./\\\\]*|))(?:[/\\\\]*)$/;\n/** JSDoc */\nfunction splitPath(filename) {\n  // Truncate files names greater than 1024 characters to avoid regex dos\n  // https://github.com/getsentry/sentry-javascript/pull/8737#discussion_r1285719172\n  const truncated = filename.length > 1024 ? `<truncated>${filename.slice(-1024)}` : filename;\n  const parts = splitPathRe.exec(truncated);\n  return parts ? parts.slice(1) : [];\n}\n\n// path.resolve([from ...], to)\n// posix version\n/** JSDoc */\nfunction resolve(...args) {\n  let resolvedPath = '';\n  let resolvedAbsolute = false;\n\n  for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    const path = i >= 0 ? args[i] : '/';\n\n    // Skip empty entries\n    if (!path) {\n      continue;\n    }\n\n    resolvedPath = `${path}/${resolvedPath}`;\n    resolvedAbsolute = path.charAt(0) === '/';\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeArray(\n    resolvedPath.split('/').filter(p => !!p),\n    !resolvedAbsolute,\n  ).join('/');\n\n  return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';\n}\n\n/** JSDoc */\nfunction trim(arr) {\n  let start = 0;\n  for (; start < arr.length; start++) {\n    if (arr[start] !== '') {\n      break;\n    }\n  }\n\n  let end = arr.length - 1;\n  for (; end >= 0; end--) {\n    if (arr[end] !== '') {\n      break;\n    }\n  }\n\n  if (start > end) {\n    return [];\n  }\n  return arr.slice(start, end - start + 1);\n}\n\n// path.relative(from, to)\n// posix version\n/** JSDoc */\nfunction relative(from, to) {\n  /* eslint-disable no-param-reassign */\n  from = resolve(from).slice(1);\n  to = resolve(to).slice(1);\n  /* eslint-enable no-param-reassign */\n\n  const fromParts = trim(from.split('/'));\n  const toParts = trim(to.split('/'));\n\n  const length = Math.min(fromParts.length, toParts.length);\n  let samePartsLength = length;\n  for (let i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  let outputParts = [];\n  for (let i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n}\n\n// path.normalize(path)\n// posix version\n/** JSDoc */\nfunction normalizePath(path) {\n  const isPathAbsolute = isAbsolute(path);\n  const trailingSlash = path.slice(-1) === '/';\n\n  // Normalize the path\n  let normalizedPath = normalizeArray(\n    path.split('/').filter(p => !!p),\n    !isPathAbsolute,\n  ).join('/');\n\n  if (!normalizedPath && !isPathAbsolute) {\n    normalizedPath = '.';\n  }\n  if (normalizedPath && trailingSlash) {\n    normalizedPath += '/';\n  }\n\n  return (isPathAbsolute ? '/' : '') + normalizedPath;\n}\n\n// posix version\n/** JSDoc */\nfunction isAbsolute(path) {\n  return path.charAt(0) === '/';\n}\n\n// posix version\n/** JSDoc */\nfunction join(...args) {\n  return normalizePath(args.join('/'));\n}\n\n/** JSDoc */\nfunction dirname(path) {\n  const result = splitPath(path);\n  const root = result[0] || '';\n  let dir = result[1];\n\n  if (!root && !dir) {\n    // No dirname whatsoever\n    return '.';\n  }\n\n  if (dir) {\n    // It has a dirname, strip trailing slash\n    dir = dir.slice(0, dir.length - 1);\n  }\n\n  return root + dir;\n}\n\n/** JSDoc */\nfunction basename(path, ext) {\n  let f = splitPath(path)[2] || '';\n  if (ext && f.slice(ext.length * -1) === ext) {\n    f = f.slice(0, f.length - ext.length);\n  }\n  return f;\n}\n\nexport { basename, dirname, isAbsolute, join, normalizePath, relative, resolve };\n//# sourceMappingURL=path.js.map\n","import { uuid4 } from './misc.js';\n\n/**\n * Returns a new minimal propagation context.\n *\n * @deprecated Use `generateTraceId` and `generateSpanId` instead.\n */\nfunction generatePropagationContext() {\n  return {\n    traceId: generateTraceId(),\n    spanId: generateSpanId(),\n  };\n}\n\n/**\n * Generate a random, valid trace ID.\n */\nfunction generateTraceId() {\n  return uuid4();\n}\n\n/**\n * Generate a random, valid span ID.\n */\nfunction generateSpanId() {\n  return uuid4().substring(16);\n}\n\nexport { generatePropagationContext, generateSpanId, generateTraceId };\n//# sourceMappingURL=propagationContext.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 the given category is disabled until for rate limiting.\n * In case no category-specific limit is set but a general rate limit across all categories is active,\n * that time is returned.\n *\n * @return the time in ms that the category is disabled until or 0 if there's no active rate limit.\n */\nfunction disabledUntil(limits, dataCategory) {\n  return limits[dataCategory] || limits.all || 0;\n}\n\n/**\n * Checks if a category is rate limited\n */\nfunction isRateLimited(limits, dataCategory, now = Date.now()) {\n  return disabledUntil(limits, dataCategory) > now;\n}\n\n/**\n * Update ratelimits from incoming headers.\n *\n * @return the updated RateLimits object.\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>: <namespaces>\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     *     <namespaces> Semicolon-separated list of metric namespace identifiers. Defines which namespace(s) will be affected.\n     *         Only present if rate limit applies to the metric_bucket data category.\n     */\n    for (const limit of rateLimitHeader.trim().split(',')) {\n      const [retryAfter, categories, , , namespaces] = limit.split(':', 5) ;\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          if (category === 'metric_bucket') {\n            // namespaces will be present when category === 'metric_bucket'\n            if (!namespaces || namespaces.split(';').includes('custom')) {\n              updatedRateLimits[category] = now + delay;\n            }\n          } else {\n            updatedRateLimits[category] = now + delay;\n          }\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","/**\n * @deprecated This variable has been deprecated and will be removed in the next major version.\n */\nconst validSeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'];\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 (\n    level === 'warn' ? 'warning' : ['fatal', 'error', 'warning', 'log', 'info', 'debug'].includes(level) ? level : 'log'\n  ) ;\n}\n\nexport { severityLevelFromString, validSeverityLevels };\n//# sourceMappingURL=severity.js.map\n","const STACKTRACE_FRAME_LIMIT = 50;\nconst UNKNOWN_FUNCTION = '?';\n// Used to sanitize webpack (error: *) wrapped stack errors\nconst WEBPACK_ERROR_REGEXP = /\\(error: (.*)\\)/;\nconst STRIP_FRAME_REGEXP = /captureMessage|captureException/;\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, skipFirstLines = 0, framesToPop = 0) => {\n    const frames = [];\n    const lines = stack.split('\\n');\n\n    for (let i = skipFirstLines; i < lines.length; i++) {\n      const line = lines[i] ;\n      // Ignore lines over 1kb as they are unlikely to be stack frames.\n      // Many of the regular expressions use backtracking which results in run time that increases exponentially with\n      // input size. Huge strings can result in hangs/Denial of Service:\n      // https://github.com/getsentry/sentry-javascript/issues/2286\n      if (line.length > 1024) {\n        continue;\n      }\n\n      // https://github.com/getsentry/sentry-javascript/issues/5459\n      // Remove webpack (error: *) wrappers\n      const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, '$1') : line;\n\n      // https://github.com/getsentry/sentry-javascript/issues/7813\n      // Skip Error: lines\n      if (cleanedLine.match(/\\S*Error: /)) {\n        continue;\n      }\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      if (frames.length >= STACKTRACE_FRAME_LIMIT + framesToPop) {\n        break;\n      }\n    }\n\n    return stripSentryFramesAndReverse(frames.slice(framesToPop));\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 * Removes Sentry frames from the top and bottom of the stack if present and enforces a limit of max number of frames.\n * Assumes stack input is ordered from top to bottom and returns the reverse representation so call site of the\n * function that caused the crash is the last frame in the array.\n * @hidden\n */\nfunction stripSentryFramesAndReverse(stack) {\n  if (!stack.length) {\n    return [];\n  }\n\n  const localStack = Array.from(stack);\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 (/sentryWrapped/.test(getLastStackFrame(localStack).function || '')) {\n    localStack.pop();\n  }\n\n  // Reversing in the middle of the procedure allows us to just pop the values off the stack\n  localStack.reverse();\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 (STRIP_FRAME_REGEXP.test(getLastStackFrame(localStack).function || '')) {\n    localStack.pop();\n\n    // When using synthetic events, we will have a 2 levels deep stack, as `new Error('Sentry syntheticException')`\n    // is produced within the hub itself, making it:\n    //\n    //   Sentry.captureException()\n    //   getCurrentHub().captureException()\n    //\n    // instead of just the top `Sentry` call itself.\n    // This forces us to possibly strip an additional frame in the exact same was as above.\n    if (STRIP_FRAME_REGEXP.test(getLastStackFrame(localStack).function || '')) {\n      localStack.pop();\n    }\n  }\n\n  return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map(frame => ({\n    ...frame,\n    filename: frame.filename || getLastStackFrame(localStack).filename,\n    function: frame.function || UNKNOWN_FUNCTION,\n  }));\n}\n\nfunction getLastStackFrame(arr) {\n  return arr[arr.length - 1] || {};\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/**\n * Get's stack frames from an event without needing to check for undefined properties.\n */\nfunction getFramesFromEvent(event) {\n  const exception = event.exception;\n\n  if (exception) {\n    const frames = [];\n    try {\n      // @ts-expect-error Object could be undefined\n      exception.values.forEach(value => {\n        // @ts-expect-error Value could be undefined\n        if (value.stacktrace.frames) {\n          // @ts-expect-error Value could be undefined\n          frames.push(...value.stacktrace.frames);\n        }\n      });\n      return frames;\n    } catch (_oO) {\n      return undefined;\n    }\n  }\n  return undefined;\n}\n\nexport { UNKNOWN_FUNCTION, createStackParser, getFramesFromEvent, getFunctionName, stackParserFromStackParserOptions, stripSentryFramesAndReverse };\n//# sourceMappingURL=stacktrace.js.map\n","import { isVueViewModel, isString, isRegExp } from './is.js';\n\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string (0 = unlimited)\n * @returns string Encoded\n */\nfunction truncate(str, max = 0) {\n  if (typeof str !== 'string' || max === 0) {\n    return str;\n  }\n  return str.length <= max ? str : `${str.slice(0, max)}...`;\n}\n\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nfunction snipLine(line, colno) {\n  let newLine = line;\n  const lineLength = newLine.length;\n  if (lineLength <= 150) {\n    return newLine;\n  }\n  if (colno > lineLength) {\n    // eslint-disable-next-line no-param-reassign\n    colno = lineLength;\n  }\n\n  let start = Math.max(colno - 60, 0);\n  if (start < 5) {\n    start = 0;\n  }\n\n  let end = Math.min(start + 140, lineLength);\n  if (end > lineLength - 5) {\n    end = lineLength;\n  }\n  if (end === lineLength) {\n    start = Math.max(end - 140, 0);\n  }\n\n  newLine = newLine.slice(start, end);\n  if (start > 0) {\n    newLine = `'{snip} ${newLine}`;\n  }\n  if (end < lineLength) {\n    newLine += ' {snip}';\n  }\n\n  return newLine;\n}\n\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\nfunction safeJoin(input, delimiter) {\n  if (!Array.isArray(input)) {\n    return '';\n  }\n\n  const output = [];\n  // eslint-disable-next-line @typescript-eslint/prefer-for-of\n  for (let i = 0; i < input.length; i++) {\n    const value = input[i];\n    try {\n      // This is a hack to fix a Vue3-specific bug that causes an infinite loop of\n      // console warnings. This happens when a Vue template is rendered with\n      // an undeclared variable, which we try to stringify, ultimately causing\n      // Vue to issue another warning which repeats indefinitely.\n      // see: https://github.com/getsentry/sentry-javascript/pull/8981\n      if (isVueViewModel(value)) {\n        output.push('[VueViewModel]');\n      } else {\n        output.push(String(value));\n      }\n    } catch (e) {\n      output.push('[value cannot be serialized]');\n    }\n  }\n\n  return output.join(delimiter);\n}\n\n/**\n * Checks if the given value matches a regex or string\n *\n * @param value The string to test\n * @param pattern Either a regex or a string against which `value` will be matched\n * @param requireExactStringMatch If true, `value` must match `pattern` exactly. If false, `value` will match\n * `pattern` if it contains `pattern`. Only applies to string-type patterns.\n */\nfunction isMatchingPattern(\n  value,\n  pattern,\n  requireExactStringMatch = false,\n) {\n  if (!isString(value)) {\n    return false;\n  }\n\n  if (isRegExp(pattern)) {\n    return pattern.test(value);\n  }\n  if (isString(pattern)) {\n    return requireExactStringMatch ? value === pattern : value.includes(pattern);\n  }\n\n  return false;\n}\n\n/**\n * Test the given string against an array of strings and regexes. By default, string matching is done on a\n * substring-inclusion basis rather than a strict equality basis\n *\n * @param testString The string to test\n * @param patterns The patterns against which to test the string\n * @param requireExactStringMatch If true, `testString` must match one of the given string patterns exactly in order to\n * count. If false, `testString` will match a string pattern if it contains that pattern.\n * @returns\n */\nfunction stringMatchesSomePattern(\n  testString,\n  patterns = [],\n  requireExactStringMatch = false,\n) {\n  return patterns.some(pattern => isMatchingPattern(testString, pattern, requireExactStringMatch));\n}\n\nexport { isMatchingPattern, safeJoin, snipLine, stringMatchesSomePattern, truncate };\n//# sourceMappingURL=string.js.map\n","import { DEBUG_BUILD } from './debug-build.js';\nimport { logger } from './logger.js';\nimport { GLOBAL_OBJ } from './worldwide.js';\n\nconst WINDOW = GLOBAL_OBJ ;\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-expect-error 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/**\n * isNative checks if the given function is a native implementation\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nfunction isNativeFunction(func) {\n  return func && /^function\\s+\\w+\\(\\)\\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 (typeof EdgeRuntime === 'string') {\n    return true;\n  }\n\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 (isNativeFunction(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 = isNativeFunction(sandbox.contentWindow.fetch);\n      }\n      doc.head.removeChild(sandbox);\n    } catch (err) {\n      DEBUG_BUILD &&\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\nexport { isNativeFunction, supportsDOMError, supportsDOMException, supportsErrorEvent, supportsFetch, 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/* eslint-disable @typescript-eslint/no-explicit-any */\n\n/** SyncPromise internal states */\nvar States; (function (States) {\n  /** Pending */\n  const PENDING = 0; States[States[\"PENDING\"] = PENDING] = \"PENDING\";\n  /** Resolved / OK */\n  const RESOLVED = 1; States[States[\"RESOLVED\"] = RESOLVED] = \"RESOLVED\";\n  /** Rejected / Error */\n  const REJECTED = 2; States[States[\"REJECTED\"] = REJECTED] = \"REJECTED\";\n})(States || (States = {}));\n\n// Overloads so we can call resolvedSyncPromise without arguments and generic argument\n\n/**\n * Creates a resolved sync promise.\n *\n * @param value the value to resolve the promise with\n * @returns the resolved sync promise\n */\nfunction resolvedSyncPromise(value) {\n  return new SyncPromise(resolve => {\n    resolve(value);\n  });\n}\n\n/**\n * Creates a rejected sync promise.\n *\n * @param value the value to reject the promise with\n * @returns the rejected sync promise\n */\nfunction rejectedSyncPromise(reason) {\n  return new SyncPromise((_, reject) => {\n    reject(reason);\n  });\n}\n\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nclass SyncPromise {\n\n   constructor(\n    executor,\n  ) {SyncPromise.prototype.__init.call(this);SyncPromise.prototype.__init2.call(this);SyncPromise.prototype.__init3.call(this);SyncPromise.prototype.__init4.call(this);\n    this._state = States.PENDING;\n    this._handlers = [];\n\n    try {\n      executor(this._resolve, this._reject);\n    } catch (e) {\n      this._reject(e);\n    }\n  }\n\n  /** JSDoc */\n   then(\n    onfulfilled,\n    onrejected,\n  ) {\n    return new SyncPromise((resolve, reject) => {\n      this._handlers.push([\n        false,\n        result => {\n          if (!onfulfilled) {\n            // TODO: ¯\\_(ツ)_/¯\n            // TODO: FIXME\n            resolve(result );\n          } else {\n            try {\n              resolve(onfulfilled(result));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n        reason => {\n          if (!onrejected) {\n            reject(reason);\n          } else {\n            try {\n              resolve(onrejected(reason));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n      ]);\n      this._executeHandlers();\n    });\n  }\n\n  /** JSDoc */\n   catch(\n    onrejected,\n  ) {\n    return this.then(val => val, onrejected);\n  }\n\n  /** JSDoc */\n   finally(onfinally) {\n    return new SyncPromise((resolve, reject) => {\n      let val;\n      let isRejected;\n\n      return this.then(\n        value => {\n          isRejected = false;\n          val = value;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n        reason => {\n          isRejected = true;\n          val = reason;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n      ).then(() => {\n        if (isRejected) {\n          reject(val);\n          return;\n        }\n\n        resolve(val );\n      });\n    });\n  }\n\n  /** JSDoc */\n    __init() {this._resolve = (value) => {\n    this._setResult(States.RESOLVED, value);\n  };}\n\n  /** JSDoc */\n    __init2() {this._reject = (reason) => {\n    this._setResult(States.REJECTED, reason);\n  };}\n\n  /** JSDoc */\n    __init3() {this._setResult = (state, value) => {\n    if (this._state !== States.PENDING) {\n      return;\n    }\n\n    if (isThenable(value)) {\n      void (value ).then(this._resolve, this._reject);\n      return;\n    }\n\n    this._state = state;\n    this._value = value;\n\n    this._executeHandlers();\n  };}\n\n  /** JSDoc */\n    __init4() {this._executeHandlers = () => {\n    if (this._state === States.PENDING) {\n      return;\n    }\n\n    const cachedHandlers = this._handlers.slice();\n    this._handlers = [];\n\n    cachedHandlers.forEach(handler => {\n      if (handler[0]) {\n        return;\n      }\n\n      if (this._state === States.RESOLVED) {\n        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 { GLOBAL_OBJ } from './worldwide.js';\n\nconst ONE_SECOND_IN_MS = 1000;\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 timestamp in seconds since the UNIX epoch using the Date API.\n *\n * TODO(v8): Return type should be rounded.\n */\nfunction dateTimestampInSeconds() {\n  return Date.now() / ONE_SECOND_IN_MS;\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 createUnixTimestampInSecondsFunc() {\n  const { performance } = GLOBAL_OBJ ;\n  if (!performance || !performance.now) {\n    return dateTimestampInSeconds;\n  }\n\n  // Some browser and environments don't have a timeOrigin, so we fallback to\n  // using Date.now() to compute the starting time.\n  const approxStartingTimeOrigin = Date.now() - performance.now();\n  const timeOrigin = performance.timeOrigin == undefined ? approxStartingTimeOrigin : performance.timeOrigin;\n\n  // performance.now() is a monotonic clock, which means it starts at 0 when the process begins. To get the current\n  // wall clock time (actual UNIX timestamp), we need to add the starting time origin and the current time elapsed.\n  //\n  // TODO: This does not account for the case where the monotonic clock that powers performance.now() drifts from the\n  // wall clock time, which causes the returned timestamp to be inaccurate. We should investigate how to detect and\n  // correct for this.\n  // See: https://github.com/getsentry/sentry-javascript/issues/2590\n  // See: https://github.com/mdn/content/issues/4713\n  // See: https://dev.to/noamr/when-a-millisecond-is-not-a-millisecond-3h6\n  return () => {\n    return (timeOrigin + performance.now()) / ONE_SECOND_IN_MS;\n  };\n}\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 * 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 = createUnixTimestampInSecondsFunc();\n\n/**\n * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.\n *\n * @deprecated This variable will be removed in the next major version.\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 } = GLOBAL_OBJ ;\n  if (!performance || !performance.now) {\n    // eslint-disable-next-line deprecation/deprecation\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      // eslint-disable-next-line deprecation/deprecation\n      _browserPerformanceTimeOriginMode = 'timeOrigin';\n      return performance.timeOrigin;\n    } else {\n      // eslint-disable-next-line deprecation/deprecation\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  // eslint-disable-next-line deprecation/deprecation\n  _browserPerformanceTimeOriginMode = 'dateNow';\n  return dateNow;\n})();\n\nexport { _browserPerformanceTimeOriginMode, browserPerformanceTimeOrigin, dateTimestampInSeconds, timestampInSeconds };\n//# sourceMappingURL=time.js.map\n","import { baggageHeaderToDynamicSamplingContext } from './baggage.js';\nimport { generateTraceId, generateSpanId } from './propagationContext.js';\n\n// eslint-disable-next-line @sentry-internal/sdk/no-regexp-constructor -- RegExp is used for readability here\nconst 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  if (!traceparent) {\n    return undefined;\n  }\n\n  const matches = traceparent.match(TRACEPARENT_REGEXP);\n  if (!matches) {\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\n/**\n * Create a propagation context from incoming headers or\n * creates a minimal new one if the headers are undefined.\n */\nfunction propagationContextFromHeaders(\n  sentryTrace,\n  baggage,\n) {\n  const traceparentData = extractTraceparentData(sentryTrace);\n  const dynamicSamplingContext = baggageHeaderToDynamicSamplingContext(baggage);\n\n  if (!traceparentData || !traceparentData.traceId) {\n    return { traceId: generateTraceId(), spanId: generateSpanId() };\n  }\n\n  const { traceId, parentSpanId, parentSampled } = traceparentData;\n\n  const virtualSpanId = generateSpanId();\n\n  return {\n    traceId,\n    parentSpanId,\n    spanId: virtualSpanId,\n    sampled: parentSampled,\n    dsc: dynamicSamplingContext || {}, // If we have traceparent data but no DSC it means we are not head of trace and we must freeze it\n  };\n}\n\n/**\n * Create sentry-trace header from span context values.\n */\nfunction generateSentryTraceHeader(\n  traceId = generateTraceId(),\n  spanId = generateSpanId(),\n  sampled,\n) {\n  let sampledString = '';\n  if (sampled !== undefined) {\n    sampledString = sampled ? '-1' : '-0';\n  }\n  return `${traceId}-${spanId}${sampledString}`;\n}\n\nexport { TRACEPARENT_REGEXP, extractTraceparentData, generateSentryTraceHeader, propagationContextFromHeaders };\n//# sourceMappingURL=tracing.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  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    search: query,\n    hash: fragment,\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  return (urlPath.split(/[?#]/, 1) )[0];\n}\n\n/**\n * Returns number of URL segments of a passed string URL.\n *\n * @deprecated This function will be removed in the next major version.\n */\n// TODO(v9): Hoist this function into the places where we use it. (as it stands only react router v6 instrumentation)\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\n/**\n * Takes a URL object and returns a sanitized string which is safe to use as span name\n * see: https://develop.sentry.dev/sdk/data-handling/#structuring-data\n */\nfunction getSanitizedUrlString(url) {\n  const { protocol, host, path } = url;\n\n  const filteredHost =\n    (host &&\n      host\n        // Always filter out authority\n        .replace(/^.*@/, '[filtered]:[filtered]@')\n        // Don't show standard :80 (http) and :443 (https) ports to reduce the noise\n        // TODO: Use new URL global if it exists\n        .replace(/(:80)$/, '')\n        .replace(/(:443)$/, '')) ||\n    '';\n\n  return `${protocol ? `${protocol}://` : ''}${filteredHost}${path}`;\n}\n\nexport { getNumberOfUrlSegments, getSanitizedUrlString, parseUrl, stripUrlQueryAndFragment };\n//# sourceMappingURL=url.js.map\n","import { GLOBAL_OBJ } from '../worldwide.js';\n\n// Based on https://github.com/angular/angular.js/pull/13945/files\n// The MIT License\n\n\nconst WINDOW = GLOBAL_OBJ ;\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  // TODO(v9): Remove this custom check, it is pretty old and likely not needed anymore\n  const chromeVar = (WINDOW ).chrome;\n  const isChromePackagedApp = chromeVar && chromeVar.app && chromeVar.app.runtime;\n  const hasHistoryApi = 'history' in WINDOW && !!WINDOW.history.pushState && !!WINDOW.history.replaceState;\n\n  return !isChromePackagedApp && hasHistoryApi;\n}\n\nexport { supportsHistory };\n//# sourceMappingURL=supportsHistory.js.map\n","// This is a magic string replaced by rollup\n\nconst SDK_VERSION = \"8.46.0\" ;\n\nexport { SDK_VERSION };\n//# sourceMappingURL=version.js.map\n","import { SDK_VERSION } from './version.js';\n\n/** Get's the global object for the current JavaScript runtime */\nconst GLOBAL_OBJ = globalThis ;\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 versionedCarrier = (__SENTRY__[SDK_VERSION] = __SENTRY__[SDK_VERSION] || {});\n  return versionedCarrier[name] || (versionedCarrier[name] = creator());\n}\n\nexport { GLOBAL_OBJ, getGlobalSingleton };\n//# sourceMappingURL=worldwide.js.map\n","import { isThenable } from '../utils-hoist/is.js';\n\n/**\n * Wrap a callback function with error handling.\n * If an error is thrown, it will be passed to the `onError` callback and re-thrown.\n *\n * If the return value of the function is a promise, it will be handled with `maybeHandlePromiseRejection`.\n *\n * If an `onFinally` callback is provided, this will be called when the callback has finished\n * - so if it returns a promise, once the promise resolved/rejected,\n * else once the callback has finished executing.\n * The `onFinally` callback will _always_ be called, no matter if an error was thrown or not.\n */\nfunction handleCallbackErrors\n\n(\n  fn,\n  onError,\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  onFinally = () => {},\n) {\n  let maybePromiseResult;\n  try {\n    maybePromiseResult = fn();\n  } catch (e) {\n    onError(e);\n    onFinally();\n    throw e;\n  }\n\n  return maybeHandlePromiseRejection(maybePromiseResult, onError, onFinally);\n}\n\n/**\n * Maybe handle a promise rejection.\n * This expects to be given a value that _may_ be a promise, or any other value.\n * If it is a promise, and it rejects, it will call the `onError` callback.\n * Other than this, it will generally return the given value as-is.\n */\nfunction maybeHandlePromiseRejection(\n  value,\n  onError,\n  onFinally,\n) {\n  if (isThenable(value)) {\n    // @ts-expect-error - the isThenable check returns the \"wrong\" type here\n    return value.then(\n      res => {\n        onFinally();\n        return res;\n      },\n      e => {\n        onError(e);\n        onFinally();\n        throw e;\n      },\n    );\n  }\n\n  onFinally();\n  return value;\n}\n\nexport { handleCallbackErrors };\n//# sourceMappingURL=handleCallbackErrors.js.map\n","import { getClient } from '../currentScopes.js';\n\n// Treeshakable guard to remove all code related to tracing\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  if (typeof __SENTRY_TRACING__ === 'boolean' && !__SENTRY_TRACING__) {\n    return false;\n  }\n\n  const client = getClient();\n  const options = maybeOptions || (client && client.getOptions());\n  // eslint-disable-next-line deprecation/deprecation\n  return !!options && (options.enableTracing || 'tracesSampleRate' in options || 'tracesSampler' in options);\n}\n\nexport { hasTracingEnabled };\n//# sourceMappingURL=hasTracingEnabled.js.map\n","/**\n * Checks whether given url points to Sentry server\n *\n * @param url url to verify\n */\nfunction isSentryRequestUrl(url, client) {\n  const dsn = client && client.getDsn();\n  const tunnel = client && client.getOptions().tunnel;\n  return checkDsn(url, dsn) || checkTunnel(url, tunnel);\n}\n\nfunction checkTunnel(url, tunnel) {\n  if (!tunnel) {\n    return false;\n  }\n\n  return removeTrailingSlash(url) === removeTrailingSlash(tunnel);\n}\n\nfunction checkDsn(url, dsn) {\n  return dsn ? url.includes(dsn.host) : false;\n}\n\nfunction removeTrailingSlash(str) {\n  return str[str.length - 1] === '/' ? str.slice(0, -1) : str;\n}\n\nexport { isSentryRequestUrl };\n//# sourceMappingURL=isSentryRequestUrl.js.map\n","/**\n * Shallow merge two objects.\n * Does not mutate the passed in objects.\n * Undefined/empty values in the merge object will overwrite existing values.\n *\n * By default, this merges 2 levels deep.\n */\nfunction merge(initialObj, mergeObj, levels = 2) {\n  // If the merge value is not an object, or we have no merge levels left,\n  // we just set the value to the merge value\n  if (!mergeObj || typeof mergeObj !== 'object' || levels <= 0) {\n    return mergeObj;\n  }\n\n  // If the merge object is an empty object, and the initial object is not undefined, we return the initial object\n  if (initialObj && mergeObj && Object.keys(mergeObj).length === 0) {\n    return initialObj;\n  }\n\n  // Clone object\n  const output = { ...initialObj };\n\n  // Merge values into output, resursively\n  for (const key in mergeObj) {\n    if (Object.prototype.hasOwnProperty.call(mergeObj, key)) {\n      output[key] = merge(output[key], mergeObj[key], levels - 1);\n    }\n  }\n\n  return output;\n}\n\nexport { merge };\n//# sourceMappingURL=merge.js.map\n","/**\n * Tagged template function which returns parameterized representation of the message\n * For example: parameterize`This is a log statement with ${x} and ${y} params`, would return:\n * \"__sentry_template_string__\": 'This is a log statement with %s and %s params',\n * \"__sentry_template_values__\": ['first', 'second']\n * @param strings An array of string values splitted between expressions\n * @param values Expressions extracted from template string\n * @returns String with template information in __sentry_template_string__ and __sentry_template_values__ properties\n */\nfunction parameterize(strings, ...values) {\n  const formatted = new String(String.raw(strings, ...values)) ;\n  formatted.__sentry_template_string__ = strings.join('\\x00').replace(/%/g, '%%').replace(/\\0/g, '%s');\n  formatted.__sentry_template_values__ = values;\n  return formatted;\n}\n\nexport { parameterize };\n//# sourceMappingURL=parameterize.js.map\n","import { DEBUG_BUILD } from '../debug-build.js';\nimport { logger } from '../utils-hoist/logger.js';\n\n/**\n * Parse a sample rate from a given value.\n * This will either return a boolean or number sample rate, if the sample rate is valid (between 0 and 1).\n * If a string is passed, we try to convert it to a number.\n *\n * Any invalid sample rate will return `undefined`.\n */\nfunction parseSampleRate(sampleRate) {\n  if (typeof sampleRate === 'boolean') {\n    return Number(sampleRate);\n  }\n\n  const rate = typeof sampleRate === 'string' ? parseFloat(sampleRate) : sampleRate;\n  if (typeof rate !== 'number' || isNaN(rate) || rate < 0 || rate > 1) {\n    DEBUG_BUILD &&\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          sampleRate,\n        )} of type ${JSON.stringify(typeof sampleRate)}.`,\n      );\n    return undefined;\n  }\n\n  return rate;\n}\n\nexport { parseSampleRate };\n//# sourceMappingURL=parseSampleRate.js.map\n","import { getDynamicSamplingContextFromSpan } from '../tracing/dynamicSamplingContext.js';\nimport { dropUndefinedKeys } from '../utils-hoist/object.js';\nimport { merge } from './merge.js';\nimport { spanToTraceContext, getRootSpan, spanToJSON } from './spanUtils.js';\n\n/**\n * Applies data from the scope to the event and runs all event processors on it.\n */\nfunction applyScopeDataToEvent(event, data) {\n  const { fingerprint, span, breadcrumbs, sdkProcessingMetadata } = data;\n\n  // Apply general data\n  applyDataToEvent(event, data);\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 (span) {\n    applySpanToEvent(event, span);\n  }\n\n  applyFingerprintToEvent(event, fingerprint);\n  applyBreadcrumbsToEvent(event, breadcrumbs);\n  applySdkMetadataToEvent(event, sdkProcessingMetadata);\n}\n\n/** Merge data of two scopes together. */\nfunction mergeScopeData(data, mergeData) {\n  const {\n    extra,\n    tags,\n    user,\n    contexts,\n    level,\n    sdkProcessingMetadata,\n    breadcrumbs,\n    fingerprint,\n    eventProcessors,\n    attachments,\n    propagationContext,\n    transactionName,\n    span,\n  } = mergeData;\n\n  mergeAndOverwriteScopeData(data, 'extra', extra);\n  mergeAndOverwriteScopeData(data, 'tags', tags);\n  mergeAndOverwriteScopeData(data, 'user', user);\n  mergeAndOverwriteScopeData(data, 'contexts', contexts);\n\n  data.sdkProcessingMetadata = merge(data.sdkProcessingMetadata, sdkProcessingMetadata, 2);\n\n  if (level) {\n    data.level = level;\n  }\n\n  if (transactionName) {\n    data.transactionName = transactionName;\n  }\n\n  if (span) {\n    data.span = span;\n  }\n\n  if (breadcrumbs.length) {\n    data.breadcrumbs = [...data.breadcrumbs, ...breadcrumbs];\n  }\n\n  if (fingerprint.length) {\n    data.fingerprint = [...data.fingerprint, ...fingerprint];\n  }\n\n  if (eventProcessors.length) {\n    data.eventProcessors = [...data.eventProcessors, ...eventProcessors];\n  }\n\n  if (attachments.length) {\n    data.attachments = [...data.attachments, ...attachments];\n  }\n\n  data.propagationContext = { ...data.propagationContext, ...propagationContext };\n}\n\n/**\n * Merges certain scope data. Undefined values will overwrite any existing values.\n * Exported only for tests.\n */\nfunction mergeAndOverwriteScopeData\n\n(data, prop, mergeVal) {\n  data[prop] = merge(data[prop], mergeVal, 1);\n}\n\nfunction applyDataToEvent(event, data) {\n  const { extra, tags, user, contexts, level, transactionName } = data;\n\n  const cleanedExtra = dropUndefinedKeys(extra);\n  if (cleanedExtra && Object.keys(cleanedExtra).length) {\n    event.extra = { ...cleanedExtra, ...event.extra };\n  }\n\n  const cleanedTags = dropUndefinedKeys(tags);\n  if (cleanedTags && Object.keys(cleanedTags).length) {\n    event.tags = { ...cleanedTags, ...event.tags };\n  }\n\n  const cleanedUser = dropUndefinedKeys(user);\n  if (cleanedUser && Object.keys(cleanedUser).length) {\n    event.user = { ...cleanedUser, ...event.user };\n  }\n\n  const cleanedContexts = dropUndefinedKeys(contexts);\n  if (cleanedContexts && Object.keys(cleanedContexts).length) {\n    event.contexts = { ...cleanedContexts, ...event.contexts };\n  }\n\n  if (level) {\n    event.level = level;\n  }\n\n  // transaction events get their `transaction` from the root span name\n  if (transactionName && event.type !== 'transaction') {\n    event.transaction = transactionName;\n  }\n}\n\nfunction applyBreadcrumbsToEvent(event, breadcrumbs) {\n  const mergedBreadcrumbs = [...(event.breadcrumbs || []), ...breadcrumbs];\n  event.breadcrumbs = mergedBreadcrumbs.length ? mergedBreadcrumbs : undefined;\n}\n\nfunction applySdkMetadataToEvent(event, sdkProcessingMetadata) {\n  event.sdkProcessingMetadata = {\n    ...event.sdkProcessingMetadata,\n    ...sdkProcessingMetadata,\n  };\n}\n\nfunction applySpanToEvent(event, span) {\n  event.contexts = {\n    trace: spanToTraceContext(span),\n    ...event.contexts,\n  };\n\n  event.sdkProcessingMetadata = {\n    dynamicSamplingContext: getDynamicSamplingContextFromSpan(span),\n    ...event.sdkProcessingMetadata,\n  };\n\n  const rootSpan = getRootSpan(span);\n  const transactionName = spanToJSON(rootSpan).description;\n  if (transactionName && !event.transaction && event.type === 'transaction') {\n    event.transaction = transactionName;\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 */\nfunction applyFingerprintToEvent(event, fingerprint) {\n  // Make sure it's an array first and we actually have something in place\n  event.fingerprint = event.fingerprint\n    ? Array.isArray(event.fingerprint)\n      ? event.fingerprint\n      : [event.fingerprint]\n    : [];\n\n  // If we have something on the scope, then merge it with event\n  if (fingerprint) {\n    event.fingerprint = event.fingerprint.concat(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\nexport { applyScopeDataToEvent, mergeAndOverwriteScopeData, mergeScopeData };\n//# sourceMappingURL=applyScopeDataToEvent.js.map\n","import { DEFAULT_ENVIRONMENT } from '../constants.js';\nimport { getGlobalScope } from '../currentScopes.js';\nimport { notifyEventProcessors } from '../eventProcessors.js';\nimport { Scope } from '../scope.js';\nimport { getFilenameToDebugIdMap } from '../utils-hoist/debug-ids.js';\nimport { uuid4, addExceptionMechanism } from '../utils-hoist/misc.js';\nimport { normalize } from '../utils-hoist/normalize.js';\nimport { truncate } from '../utils-hoist/string.js';\nimport { dateTimestampInSeconds } from '../utils-hoist/time.js';\nimport { mergeScopeData, applyScopeDataToEvent } from './applyScopeDataToEvent.js';\n\n/**\n * This type makes sure that we get either a CaptureContext, OR an EventHint.\n * It does not allow mixing them, which could lead to unexpected outcomes, e.g. this is disallowed:\n * { user: { id: '123' }, mechanism: { handled: false } }\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 * @hidden\n */\nfunction prepareEvent(\n  options,\n  event,\n  hint,\n  scope,\n  client,\n  isolationScope,\n) {\n  const { normalizeDepth = 3, normalizeMaxBreadth = 1000 } = options;\n  const prepared = {\n    ...event,\n    event_id: event.event_id || hint.event_id || uuid4(),\n    timestamp: event.timestamp || dateTimestampInSeconds(),\n  };\n  const integrations = hint.integrations || options.integrations.map(i => i.name);\n\n  applyClientOptions(prepared, options);\n  applyIntegrationsMetadata(prepared, integrations);\n\n  if (client) {\n    client.emit('applyFrameMetadata', event);\n  }\n\n  // Only put debug IDs onto frames for error events.\n  if (event.type === undefined) {\n    applyDebugIds(prepared, options.stackParser);\n  }\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  const finalScope = getFinalScope(scope, hint.captureContext);\n\n  if (hint.mechanism) {\n    addExceptionMechanism(prepared, hint.mechanism);\n  }\n\n  const clientEventProcessors = client ? client.getEventProcessors() : [];\n\n  // This should be the last thing called, since we want that\n  // {@link Scope.addEventProcessor} gets the finished prepared event.\n  // Merge scope data together\n  const data = getGlobalScope().getScopeData();\n\n  if (isolationScope) {\n    const isolationData = isolationScope.getScopeData();\n    mergeScopeData(data, isolationData);\n  }\n\n  if (finalScope) {\n    const finalScopeData = finalScope.getScopeData();\n    mergeScopeData(data, finalScopeData);\n  }\n\n  const attachments = [...(hint.attachments || []), ...data.attachments];\n  if (attachments.length) {\n    hint.attachments = attachments;\n  }\n\n  applyScopeDataToEvent(prepared, data);\n\n  const eventProcessors = [\n    ...clientEventProcessors,\n    // Run scope event processors _after_ all other processors\n    ...data.eventProcessors,\n  ];\n\n  const result = notifyEventProcessors(eventProcessors, prepared, hint);\n\n  return result.then(evt => {\n    if (evt) {\n      // We apply the debug_meta field only after all event processors have ran, so that if any event processors modified\n      // file names (e.g.the RewriteFrames integration) the filename -> debug ID relationship isn't destroyed.\n      // This should not cause any PII issues, since we're only moving data that is already on the event and not adding\n      // any new data\n      applyDebugMeta(evt);\n    }\n\n    if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {\n      return normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);\n    }\n    return evt;\n  });\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 *\n * Only exported for tests.\n *\n * @param event event instance to be enhanced\n */\nfunction applyClientOptions(event, options) {\n  const { environment, release, dist, maxValueLength = 250 } = options;\n\n  // empty strings do not make sense for environment, release, and dist\n  // so we handle them the same as if they were not provided\n  event.environment = event.environment || environment || DEFAULT_ENVIRONMENT;\n\n  if (!event.release && release) {\n    event.release = release;\n  }\n\n  if (!event.dist && dist) {\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 * Puts debug IDs into the stack frames of an error event.\n */\nfunction applyDebugIds(event, stackParser) {\n  // Build a map of filename -> debug_id\n  const filenameDebugIdMap = getFilenameToDebugIdMap(stackParser);\n\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    event.exception.values.forEach(exception => {\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      exception.stacktrace.frames.forEach(frame => {\n        if (filenameDebugIdMap && frame.filename) {\n          frame.debug_id = filenameDebugIdMap[frame.filename];\n        }\n      });\n    });\n  } catch (e) {\n    // To save bundle size we're just try catching here instead of checking for the existence of all the different objects.\n  }\n}\n\n/**\n * Moves debug IDs from the stack frames of an error event into the debug_meta field.\n */\nfunction applyDebugMeta(event) {\n  // Extract debug IDs and filenames from the stack frames on the event.\n  const filenameDebugIdMap = {};\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    event.exception.values.forEach(exception => {\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      exception.stacktrace.frames.forEach(frame => {\n        if (frame.debug_id) {\n          if (frame.abs_path) {\n            filenameDebugIdMap[frame.abs_path] = frame.debug_id;\n          } else if (frame.filename) {\n            filenameDebugIdMap[frame.filename] = frame.debug_id;\n          }\n          delete frame.debug_id;\n        }\n      });\n    });\n  } catch (e) {\n    // To save bundle size we're just try catching here instead of checking for the existence of all the different objects.\n  }\n\n  if (Object.keys(filenameDebugIdMap).length === 0) {\n    return;\n  }\n\n  // Fill debug_meta information\n  event.debug_meta = event.debug_meta || {};\n  event.debug_meta.images = event.debug_meta.images || [];\n  const images = event.debug_meta.images;\n  Object.entries(filenameDebugIdMap).forEach(([filename, debug_id]) => {\n    images.push({\n      type: 'sourcemap',\n      code_file: filename,\n      debug_id,\n    });\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 */\nfunction applyIntegrationsMetadata(event, integrationNames) {\n  if (integrationNames.length > 0) {\n    event.sdk = event.sdk || {};\n    event.sdk.integrations = [...(event.sdk.integrations || []), ...integrationNames];\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 */\nfunction 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      return {\n        ...span,\n        ...(span.data && {\n          data: normalize(span.data, depth, maxBreadth),\n        }),\n      };\n    });\n  }\n\n  // event.contexts.flags (FeatureFlagContext) stores context for our feature\n  // flag integrations. It has a greater nesting depth than our other typed\n  // Contexts, so we re-normalize with a fixed depth of 3 here. We do not want\n  // to skip this in case of conflicting, user-provided context.\n  if (event.contexts && event.contexts.flags && normalized.contexts) {\n    normalized.contexts.flags = normalize(event.contexts.flags, 3, maxBreadth);\n  }\n\n  return normalized;\n}\n\nfunction getFinalScope(\n  scope,\n  captureContext,\n) {\n  if (!captureContext) {\n    return scope;\n  }\n\n  const finalScope = scope ? scope.clone() : new Scope();\n  finalScope.update(captureContext);\n  return finalScope;\n}\n\n/**\n * Parse either an `EventHint` directly, or convert a `CaptureContext` to an `EventHint`.\n * This is used to allow to update method signatures that used to accept a `CaptureContext` but should now accept an `EventHint`.\n */\nfunction parseEventHintOrCaptureContext(\n  hint,\n) {\n  if (!hint) {\n    return undefined;\n  }\n\n  // If you pass a Scope or `() => Scope` as CaptureContext, we just return this as captureContext\n  if (hintIsScopeOrFunction(hint)) {\n    return { captureContext: hint };\n  }\n\n  if (hintIsScopeContext(hint)) {\n    return {\n      captureContext: hint,\n    };\n  }\n\n  return hint;\n}\n\nfunction hintIsScopeOrFunction(\n  hint,\n) {\n  return hint instanceof Scope || typeof hint === 'function';\n}\n\nconst captureContextKeys = [\n  'user',\n  'level',\n  'extra',\n  'contexts',\n  'tags',\n  'fingerprint',\n  'requestSession',\n  'propagationContext',\n] ;\n\nfunction hintIsScopeContext(hint) {\n  return Object.keys(hint).some(key => captureContextKeys.includes(key ));\n}\n\nexport { applyClientOptions, applyDebugIds, applyDebugMeta, parseEventHintOrCaptureContext, prepareEvent };\n//# sourceMappingURL=prepareEvent.js.map\n","import { SDK_VERSION } from '../utils-hoist/version.js';\n\n/**\n * A builder for the SDK metadata in the options for the SDK initialization.\n *\n * Note: This function is identical to `buildMetadata` in Remix and NextJS and SvelteKit.\n * We don't extract it for bundle size reasons.\n * @see https://github.com/getsentry/sentry-javascript/pull/7404\n * @see https://github.com/getsentry/sentry-javascript/pull/4196\n *\n * If you make changes to this function consider updating the others as well.\n *\n * @param options SDK options object that gets mutated\n * @param names list of package names\n */\nfunction applySdkMetadata(options, name, names = [name], source = 'npm') {\n  const metadata = options._metadata || {};\n\n  if (!metadata.sdk) {\n    metadata.sdk = {\n      name: `sentry.javascript.${name}`,\n      packages: names.map(name => ({\n        name: `${source}:@sentry/${name}`,\n        version: SDK_VERSION,\n      })),\n      version: SDK_VERSION,\n    };\n  }\n\n  options._metadata = metadata;\n}\n\nexport { applySdkMetadata };\n//# sourceMappingURL=sdkMetadata.js.map\n","import { addNonEnumerableProperty } from '../utils-hoist/object.js';\n\nconst SCOPE_SPAN_FIELD = '_sentrySpan';\n\n/**\n * Set the active span for a given scope.\n * NOTE: This should NOT be used directly, but is only used internally by the trace methods.\n */\nfunction _setSpanForScope(scope, span) {\n  if (span) {\n    addNonEnumerableProperty(scope , SCOPE_SPAN_FIELD, span);\n  } else {\n    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n    delete (scope )[SCOPE_SPAN_FIELD];\n  }\n}\n\n/**\n * Get the active span for a given scope.\n * NOTE: This should NOT be used directly, but is only used internally by the trace methods.\n */\nfunction _getSpanForScope(scope) {\n  return scope[SCOPE_SPAN_FIELD];\n}\n\nexport { _getSpanForScope, _setSpanForScope };\n//# sourceMappingURL=spanOnScope.js.map\n","import { getAsyncContextStrategy } from '../asyncContext/index.js';\nimport { getMainCarrier } from '../carrier.js';\nimport { getCurrentScope } from '../currentScopes.js';\nimport { getMetricSummaryJsonForSpan, updateMetricSummaryOnSpan } from '../metrics/metric-summary.js';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '../semanticAttributes.js';\nimport { SPAN_STATUS_UNSET, SPAN_STATUS_OK } from '../tracing/spanstatus.js';\nimport { consoleSandbox } from '../utils-hoist/logger.js';\nimport { dropUndefinedKeys, addNonEnumerableProperty } from '../utils-hoist/object.js';\nimport { generateSpanId } from '../utils-hoist/propagationContext.js';\nimport { timestampInSeconds } from '../utils-hoist/time.js';\nimport { generateSentryTraceHeader } from '../utils-hoist/tracing.js';\nimport { _getSpanForScope } from './spanOnScope.js';\n\n// These are aligned with OpenTelemetry trace flags\nconst TRACE_FLAG_NONE = 0x0;\nconst TRACE_FLAG_SAMPLED = 0x1;\n\n// todo(v9): Remove this once we've stopped dropping spans via `beforeSendSpan`\nlet hasShownSpanDropWarning = false;\n\n/**\n * Convert a span to a trace context, which can be sent as the `trace` context in an event.\n * By default, this will only include trace_id, span_id & parent_span_id.\n * If `includeAllData` is true, it will also include data, op, status & origin.\n */\nfunction spanToTransactionTraceContext(span) {\n  const { spanId: span_id, traceId: trace_id } = span.spanContext();\n  const { data, op, parent_span_id, status, origin } = spanToJSON(span);\n\n  return dropUndefinedKeys({\n    parent_span_id,\n    span_id,\n    trace_id,\n    data,\n    op,\n    status,\n    origin,\n  });\n}\n\n/**\n * Convert a span to a trace context, which can be sent as the `trace` context in a non-transaction event.\n */\nfunction spanToTraceContext(span) {\n  const { spanId, traceId: trace_id, isRemote } = span.spanContext();\n\n  // If the span is remote, we use a random/virtual span as span_id to the trace context,\n  // and the remote span as parent_span_id\n  const parent_span_id = isRemote ? spanId : spanToJSON(span).parent_span_id;\n  const span_id = isRemote ? generateSpanId() : spanId;\n\n  return dropUndefinedKeys({\n    parent_span_id,\n    span_id,\n    trace_id,\n  });\n}\n\n/**\n * Convert a Span to a Sentry trace header.\n */\nfunction spanToTraceHeader(span) {\n  const { traceId, spanId } = span.spanContext();\n  const sampled = spanIsSampled(span);\n  return generateSentryTraceHeader(traceId, spanId, sampled);\n}\n\n/**\n * Convert a span time input into a timestamp in seconds.\n */\nfunction spanTimeInputToSeconds(input) {\n  if (typeof input === 'number') {\n    return ensureTimestampInSeconds(input);\n  }\n\n  if (Array.isArray(input)) {\n    // See {@link HrTime} for the array-based time format\n    return input[0] + input[1] / 1e9;\n  }\n\n  if (input instanceof Date) {\n    return ensureTimestampInSeconds(input.getTime());\n  }\n\n  return timestampInSeconds();\n}\n\n/**\n * Converts a timestamp to second, if it was in milliseconds, or keeps it as second.\n */\nfunction ensureTimestampInSeconds(timestamp) {\n  const isMs = timestamp > 9999999999;\n  return isMs ? timestamp / 1000 : timestamp;\n}\n\n/**\n * Convert a span to a JSON representation.\n */\n// Note: Because of this, we currently have a circular type dependency (which we opted out of in package.json).\n// This is not avoidable as we need `spanToJSON` in `spanUtils.ts`, which in turn is needed by `span.ts` for backwards compatibility.\n// And `spanToJSON` needs the Span class from `span.ts` to check here.\nfunction spanToJSON(span) {\n  if (spanIsSentrySpan(span)) {\n    return span.getSpanJSON();\n  }\n\n  try {\n    const { spanId: span_id, traceId: trace_id } = span.spanContext();\n\n    // Handle a span from @opentelemetry/sdk-base-trace's `Span` class\n    if (spanIsOpenTelemetrySdkTraceBaseSpan(span)) {\n      const { attributes, startTime, name, endTime, parentSpanId, status } = span;\n\n      return dropUndefinedKeys({\n        span_id,\n        trace_id,\n        data: attributes,\n        description: name,\n        parent_span_id: parentSpanId,\n        start_timestamp: spanTimeInputToSeconds(startTime),\n        // This is [0,0] by default in OTEL, in which case we want to interpret this as no end time\n        timestamp: spanTimeInputToSeconds(endTime) || undefined,\n        status: getStatusMessage(status),\n        op: attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP],\n        origin: attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] ,\n        _metrics_summary: getMetricSummaryJsonForSpan(span),\n      });\n    }\n\n    // Finally, at least we have `spanContext()`....\n    return {\n      span_id,\n      trace_id,\n    };\n  } catch (e) {\n    return {};\n  }\n}\n\nfunction spanIsOpenTelemetrySdkTraceBaseSpan(span) {\n  const castSpan = span ;\n  return !!castSpan.attributes && !!castSpan.startTime && !!castSpan.name && !!castSpan.endTime && !!castSpan.status;\n}\n\n/** Exported only for tests. */\n\n/**\n * Sadly, due to circular dependency checks we cannot actually import the Span class here and check for instanceof.\n * :( So instead we approximate this by checking if it has the `getSpanJSON` method.\n */\nfunction spanIsSentrySpan(span) {\n  return typeof (span ).getSpanJSON === 'function';\n}\n\n/**\n * Returns true if a span is sampled.\n * In most cases, you should just use `span.isRecording()` instead.\n * However, this has a slightly different semantic, as it also returns false if the span is finished.\n * So in the case where this distinction is important, use this method.\n */\nfunction spanIsSampled(span) {\n  // We align our trace flags with the ones OpenTelemetry use\n  // So we also check for sampled the same way they do.\n  const { traceFlags } = span.spanContext();\n  return traceFlags === TRACE_FLAG_SAMPLED;\n}\n\n/** Get the status message to use for a JSON representation of a span. */\nfunction getStatusMessage(status) {\n  if (!status || status.code === SPAN_STATUS_UNSET) {\n    return undefined;\n  }\n\n  if (status.code === SPAN_STATUS_OK) {\n    return 'ok';\n  }\n\n  return status.message || 'unknown_error';\n}\n\nconst CHILD_SPANS_FIELD = '_sentryChildSpans';\nconst ROOT_SPAN_FIELD = '_sentryRootSpan';\n\n/**\n * Adds an opaque child span reference to a span.\n */\nfunction addChildSpanToSpan(span, childSpan) {\n  // We store the root span reference on the child span\n  // We need this for `getRootSpan()` to work\n  const rootSpan = span[ROOT_SPAN_FIELD] || span;\n  addNonEnumerableProperty(childSpan , ROOT_SPAN_FIELD, rootSpan);\n\n  // We store a list of child spans on the parent span\n  // We need this for `getSpanDescendants()` to work\n  if (span[CHILD_SPANS_FIELD]) {\n    span[CHILD_SPANS_FIELD].add(childSpan);\n  } else {\n    addNonEnumerableProperty(span, CHILD_SPANS_FIELD, new Set([childSpan]));\n  }\n}\n\n/** This is only used internally by Idle Spans. */\nfunction removeChildSpanFromSpan(span, childSpan) {\n  if (span[CHILD_SPANS_FIELD]) {\n    span[CHILD_SPANS_FIELD].delete(childSpan);\n  }\n}\n\n/**\n * Returns an array of the given span and all of its descendants.\n */\nfunction getSpanDescendants(span) {\n  const resultSet = new Set();\n\n  function addSpanChildren(span) {\n    // This exit condition is required to not infinitely loop in case of a circular dependency.\n    if (resultSet.has(span)) {\n      return;\n      // We want to ignore unsampled spans (e.g. non recording spans)\n    } else if (spanIsSampled(span)) {\n      resultSet.add(span);\n      const childSpans = span[CHILD_SPANS_FIELD] ? Array.from(span[CHILD_SPANS_FIELD]) : [];\n      for (const childSpan of childSpans) {\n        addSpanChildren(childSpan);\n      }\n    }\n  }\n\n  addSpanChildren(span);\n\n  return Array.from(resultSet);\n}\n\n/**\n * Returns the root span of a given span.\n */\nfunction getRootSpan(span) {\n  return span[ROOT_SPAN_FIELD] || span;\n}\n\n/**\n * Returns the currently active span.\n */\nfunction getActiveSpan() {\n  const carrier = getMainCarrier();\n  const acs = getAsyncContextStrategy(carrier);\n  if (acs.getActiveSpan) {\n    return acs.getActiveSpan();\n  }\n\n  return _getSpanForScope(getCurrentScope());\n}\n\n/**\n * Updates the metric summary on the currently active span\n */\nfunction updateMetricSummaryOnActiveSpan(\n  metricType,\n  sanitizedName,\n  value,\n  unit,\n  tags,\n  bucketKey,\n) {\n  const span = getActiveSpan();\n  if (span) {\n    updateMetricSummaryOnSpan(span, metricType, sanitizedName, value, unit, tags, bucketKey);\n  }\n}\n\n/**\n * Logs a warning once if `beforeSendSpan` is used to drop spans.\n *\n * todo(v9): Remove this once we've stopped dropping spans via `beforeSendSpan`.\n */\nfunction showSpanDropWarning() {\n  if (!hasShownSpanDropWarning) {\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.warn(\n        '[Sentry] Deprecation warning: Returning null from `beforeSendSpan` will be disallowed from SDK version 9.0.0 onwards. The callback will only support mutating spans. To drop certain spans, configure the respective integrations directly.',\n      );\n    });\n    hasShownSpanDropWarning = true;\n  }\n}\n\nexport { TRACE_FLAG_NONE, TRACE_FLAG_SAMPLED, addChildSpanToSpan, getActiveSpan, getRootSpan, getSpanDescendants, getStatusMessage, removeChildSpanFromSpan, showSpanDropWarning, spanIsSampled, spanTimeInputToSeconds, spanToJSON, spanToTraceContext, spanToTraceHeader, spanToTransactionTraceContext, updateMetricSummaryOnActiveSpan };\n//# sourceMappingURL=spanUtils.js.map\n","import { getAsyncContextStrategy } from '../asyncContext/index.js';\nimport { getMainCarrier } from '../carrier.js';\nimport { getClient, getCurrentScope } from '../currentScopes.js';\nimport { isEnabled } from '../exports.js';\nimport '../tracing/errors.js';\nimport '../utils-hoist/version.js';\nimport '../utils-hoist/debug-build.js';\nimport { logger } from '../utils-hoist/logger.js';\nimport '../debug-build.js';\nimport '../utils-hoist/time.js';\nimport { getActiveSpan, spanToTraceHeader } from './spanUtils.js';\nimport { TRACEPARENT_REGEXP, generateSentryTraceHeader } from '../utils-hoist/tracing.js';\nimport { getDynamicSamplingContextFromSpan, getDynamicSamplingContextFromScope } from '../tracing/dynamicSamplingContext.js';\nimport { dynamicSamplingContextToSentryBaggageHeader } from '../utils-hoist/baggage.js';\n\n/**\n * Extracts trace propagation data from the current span or from the client's scope (via transaction or propagation\n * context) and serializes it to `sentry-trace` and `baggage` values to strings. These values can be used to propagate\n * a trace via our tracing Http headers or Html `<meta>` tags.\n *\n * This function also applies some validation to the generated sentry-trace and baggage values to ensure that\n * only valid strings are returned.\n *\n * @returns an object with the tracing data values. The object keys are the name of the tracing key to be used as header\n * or meta tag name.\n */\nfunction getTraceData(options = {}) {\n  const client = getClient();\n  if (!isEnabled() || !client) {\n    return {};\n  }\n\n  const carrier = getMainCarrier();\n  const acs = getAsyncContextStrategy(carrier);\n  if (acs.getTraceData) {\n    return acs.getTraceData(options);\n  }\n\n  const scope = getCurrentScope();\n  const span = options.span || getActiveSpan();\n  const sentryTrace = span ? spanToTraceHeader(span) : scopeToTraceHeader(scope);\n  const dsc = span ? getDynamicSamplingContextFromSpan(span) : getDynamicSamplingContextFromScope(client, scope);\n  const baggage = dynamicSamplingContextToSentryBaggageHeader(dsc);\n\n  const isValidSentryTraceHeader = TRACEPARENT_REGEXP.test(sentryTrace);\n  if (!isValidSentryTraceHeader) {\n    logger.warn('Invalid sentry-trace data. Cannot generate trace data');\n    return {};\n  }\n\n  return {\n    'sentry-trace': sentryTrace,\n    baggage,\n  };\n}\n\n/**\n * Get a sentry-trace header value for the given scope.\n */\nfunction scopeToTraceHeader(scope) {\n  // TODO(v9): Use generateSpanId() instead of spanId\n  // eslint-disable-next-line deprecation/deprecation\n  const { traceId, sampled, spanId } = scope.getPropagationContext();\n  return generateSentryTraceHeader(traceId, spanId, sampled);\n}\n\nexport { getTraceData };\n//# sourceMappingURL=traceData.js.map\n"],"names":["FROZEN_DSC_FIELD","freezeDscOnSpan","span","dsc","spanWithMaybeDsc","getDynamicSamplingContextFromClient","trace_id","client","options","getOptions","publicKey","public_key","getDsn","environment","release","emit","getDynamicSamplingContextFromScope","scope","propagationContext","getPropagationContext","traceId","getDynamicSamplingContextFromSpan","rootSpan","frozenDsc","traceState","spanContext","traceStateDsc","get","dscOnTraceState","jsonSpan","attributes","data","maybeSampleRate","sample_rate","source","name","description","transaction","sampled","String","spanToBaggageHeader","errorsInstrumented","registerSpanErrorInstrumentation","errorCallback","activeSpan","message","log","setStatus","code","tag","addTracingExtensions","TRACING_DEFAULTS","idleTimeout","finalTimeout","childSpanTimeout","FINISH_REASON_HEARTBEAT_FAILED","FINISH_REASON_IDLE_TIMEOUT","FINISH_REASON_FINAL_TIMEOUT","FINISH_REASON_EXTERNAL_FINISH","startIdleSpan","startSpanOptions","activities","Map","_idleTimeoutID","_finished","_finishReason","_autoFinishAllowed","disableAutoFinish","_cleanupHooks","beforeSpanEnd","previousActiveSpan","_startIdleSpan","_cancelIdleTimeout","clearTimeout","undefined","_restartIdleTimeout","endTimestamp","setTimeout","size","end","_restartChildSpanTimeout","onIdleSpanEnded","clear","forEach","cleanup","spanJSON","start_timestamp","startTimestamp","setAttribute","op","childSpans","filter","child","discardedSpans","childSpan","isRecording","JSON","stringify","childSpanJSON","timestamp","childEndTimestamp","childStartTimestamp","spanStartedBeforeIdleSpanEnd","spanEndedBeforeFinalTimeout","stringifiedSpan","Proxy","apply","target","thisArg","args","definedEndTimestamp","rest","spanEndTimestamp","spans","length","Reflect","childEndTimestamps","map","latestSpanEndTimestamp","Math","max","spanStartTimestamp","min","Infinity","push","on","startedSpan","spanId","includes","set","endedSpan","has","delete","spanToAllowAutoFinish","setMeasurement","value","unit","addEvent","timedEventsToMeasurements","events","measurements","event","SentryNonRecordingSpan","constructor","this","_traceId","_spanId","traceFlags","_timestamp","_key","_value","setAttributes","_values","_status","updateName","_name","_attributesOrStartTime","_startTime","addLink","_link","addLinks","_links","recordException","_exception","_time","SPAN_STATUS_UNSET","SPAN_STATUS_OK","SPAN_STATUS_ERROR","getSpanStatusFromHttpCode","httpStatus","setHttpStatus","spanStatus","SCOPE_ON_START_SPAN_FIELD","ISOLATION_SCOPE_ON_START_SPAN_FIELD","getCapturedScopesOnSpan","isolationScope","SentrySpan","_attributes","parentSpanId","_parentSpanId","_sampled","_endTime","_events","_isStandaloneSpan","isStandalone","_onSpanEnded","key","Object","keys","updateStartTime","timeInput","msg","logger","logSpanEnd","getSpanJSON","parent_span_id","span_id","status","origin","_metrics_summary","g","profile_id","exclusive_time","is_segment","segment_id","attributesOrStartTime","startTime","time","isSpanTimeInput","isStandaloneSpan","envelope","spanItems","recordDroppedEvent","sendEnvelope","sendSpanEnvelope","transactionEvent","_convertSpanToTransaction","captureEvent","isFullFinishedSpan","warn","capturedSpanScope","capturedSpanIsolationScope","getClient","contexts","trace","sort","a","b","slice","type","sdkProcessingMetadata","dynamicSamplingContext","transaction_info","Date","Array","isArray","input","SUPPRESS_TRACING_KEY","startSpan","callback","acs","getAcs","spanArguments","parseSentrySpanArguments","forceTransaction","parentSpan","customParentSpan","getActiveSpanWrapper","wrapper","getParentSpan","onlyIfParent","createChildOrRootSpan","handleCallbackErrors","startSpanManual","finishAndSetSpan","startInactiveSpan","withActiveSpan","continueTrace","sentryTrace","baggage","setPropagationContext","suppressTracing","setSDKProcessingMetadata","startNewTrace","info","hasTracingEnabled","getScopeData","_startChildSpan","parentSampled","_startRootSpan","isRootSpan","header","infoParts","join","logSpanStart","setCapturedScopesOnSpan","initialCtx","experimental","standalone","ctx","carrier","sampleRate","samplingContext","tracesSampler","tracesSampleRate","parsedSampleRate","parseSampleRate","random","Number","sampleSpan","transactionContext","parentSpanIsAlwaysRootSpan","makePromiseBuffer","limit","buffer","remove","task","splice","indexOf","Promise","resolve","$","add","taskProducer","then","drain","timeout","reject","counter","capturedSetTimeout","item","DEFAULT_TRANSPORT_BUFFER_SIZE","createTransport","makeRequest","bufferSize","rateLimits","send","filteredEnvelopeItems","dataCategory","getEventForEnvelopeItem","filteredEnvelope","recordEnvelopeLoss","reason","body","response","statusCode","error","result","flush","eventFromEnvelope","env","types","makeMultiplexedTransport","matcher","fallbackTransport","otherTransports","getTransport","dsn","transport","validatedDsn","url","tunnel","async","makeOverrideReleaseTransport","transports","getEvent","eventTypes","t","transportsWithFallback","all","overrideDsn","allTransports","values","every","r","MIN_DELAY","START_DELAY","MAX_DELAY","makeOfflineTransport","createStore","Error","store","flushTimer","retryDelay","flushIn","delay","found","shift","sent_at","toISOString","catch","e","unref","flushWithBackOff","isRetry","headers","shouldStore","shouldQueue","unshift","flushAtStartup","applyAggregateErrorsToEvent","exceptionFromErrorImplementation","parser","maxValueLimit","hint","exception","originalException","exceptions","maxValueLength","aggregateExceptionsFromError","prevExceptions","exceptionId","newExceptions","applyExceptionGroupFieldsForParentException","newException","newExceptionId","applyExceptionGroupFieldsForChildException","errors","childError","i","mechanism","handled","is_exception_group","exception_id","parentId","parent_id","SENTRY_BAGGAGE_KEY_PREFIX","SENTRY_BAGGAGE_KEY_PREFIX_REGEX","MAX_BAGGAGE_STRING_LENGTH","baggageHeaderToDynamicSamplingContext","baggageHeader","baggageObject","reduce","acc","curr","currBaggageObject","baggageHeaderToObject","entries","parseBaggageHeader","match","dynamicSamplingContextToSentryBaggageHeader","object","objectKey","objectValue","currentIndex","baggageEntry","encodeURIComponent","newBaggageHeader","objectToBaggageHeader","dscKey","dscValue","split","keyOrValue","decodeURIComponent","trim","getBreadcrumbLogLevelFromHttpStatusCode","WINDOW","DEFAULT_MAX_STRING_LENGTH","htmlTreeAsString","elem","currentElem","MAX_TRAVERSE_HEIGHT","out","height","len","separator","sepLength","nextStr","keyAttrs","maxStringLength","_htmlElementAsString","parentNode","reverse","_oO","el","tagName","HTMLElement","dataset","toLowerCase","keyAttrPairs","keyAttr","getAttribute","keyAttrPair","id","className","classes","c","allowedAttrs","k","attr","getLocationHref","document","location","href","oO","getDomElement","selector","querySelector","getComponentName","_nullishCoalesce","lhs","rhsFn","_optionalChain","ops","lastAccessLHS","fn","call","createClientReportEnvelope","discarded_events","clientReportItem","DEBUG_BUILD","__SENTRY_DEBUG__","parsedStackResults","lastKeysCount","cachedFilenameDebugIds","getFilenameToDebugIdMap","stackParser","debugIdMap","_sentryDebugIds","debugIdKeys","stackKey","parsedStack","stackFrame","filename","debugId","getDebugImagesForResources","resource_paths","filenameDebugIdMap","images","path","code_file","debug_id","DSN_REGEX","dsnToString","withPassword","host","pass","port","projectId","protocol","dsnFromString","str","exec","console","lastPath","pop","projectMatch","dsnFromComponents","components","makeDsn","from","find","component","isValidProtocol","isNaN","parseInt","validateDsn","isBrowserBundle","__SENTRY_BROWSER_BUNDLE__","getSDKSource","createEnvelope","items","addItemToEnvelope","newItem","forEachEnvelopeItem","envelopeItems","envelopeItem","envelopeContainsItemType","_","encodeUTF8","__SENTRY__","encodePolyfill","TextEncoder","encode","serializeEnvelope","envHeaders","parts","append","next","itemHeaders","payload","Uint8Array","stringifiedPayload","buffers","totalLength","buf","merged","offset","concatBuffers","parseEnvelope","readBinary","bin","subarray","readJson","parse","decodePolyfill","TextDecoder","decode","envelopeHeader","itemHeader","binaryLength","createSpanEnvelopeItem","spanJson","createAttachmentEnvelopeItem","attachment","content_type","contentType","attachment_type","attachmentType","ITEM_TYPE_TO_DATA_CATEGORY_MAP","session","sessions","client_report","user_report","profile","profile_chunk","replay_event","replay_recording","check_in","feedback","statsd","raw_security","envelopeItemTypeToDataCategory","getSdkMetadataForEnvelopeHeader","metadataOrEvent","sdk","version","createEventEnvelopeHeaders","sdkInfo","event_id","SentryError","logLevel","super","prototype","setPrototypeOf","addConsoleInstrumentationHandler","handler","instrumentConsole","level","originalConsoleMethod","handlerData","addFetchInstrumentationHandler","skipNativeFetchCheck","instrumentFetch","addFetchEndInstrumentationHandler","streamHandler","onFetchResolved","originalFetch","virtualError","method","fetchArgs","getUrlFromResource","hasProp","toUpperCase","arg","parseFetchArgs","fetchData","stack","clonedResponseForResolving","clone","res","onFinishedResolving","responseReader","getReader","maxFetchDurationTimeout","cancel","readingActive","chunkTimeout","done","read","releaseLock","resolveResponse","obj","prop","resource","toString","_oldOnErrorHandler","addGlobalErrorInstrumentationHandler","instrumentError","onerror","line","column","arguments","__SENTRY_INSTRUMENTED__","_oldOnUnhandledRejectionHandler","addGlobalUnhandledRejectionInstrumentationHandler","instrumentUnhandledRejection","onunhandledrejection","handlers","instrumented","addHandler","maybeInstrument","instrumentFn","triggerHandlers","typeHandlers","objectToString","isError","wat","isInstanceOf","isBuiltin","isErrorEvent","isDOMError","isDOMException","isString","isParameterizedString","isPrimitive","isPlainObject","isEvent","Event","isElement","Element","isRegExp","isThenable","Boolean","isSyntheticEvent","base","_e","isVueViewModel","__isVue","_isVue","isBrowser","window","process","isElectronNodeRenderer","CONSOLE_LEVELS","originalConsoleMethods","consoleSandbox","wrappedFuncs","wrappedLevels","enabled","enable","disable","isEnabled","uuid4","gbl","crypto","msCrypto","getRandomByte","randomUUID","replace","getRandomValues","typedArray","getFirstException","getEventDescription","eventId","firstException","addExceptionTypeValue","addExceptionMechanism","newMechanism","currentMechanism","mergedData","addContextToFrame","lines","frame","linesOfContext","lineno","maxLines","sourceLine","pre_context","lineIndex","context_line","colno","post_context","checkOrSetAlreadyCaught","__sentry_captured__","isAlreadyCaptured","err","normalize","depth","maxProperties","visit","ERROR","normalizeToSize","maxSize","normalized","encodeURI","utf8Length","memo","hasWeakSet","WeakSet","inner","memoBuilder","memoize","unmemoize","isFinite","stringified","global","is","objName","getPrototypeOf","getConstructorName","test","stringifyValue","startsWith","remainingDepth","valueWithToJSON","toJSON","numAdded","visitable","visitKey","hasOwnProperty","visitValue","fill","replacementFactory","original","wrapped","markFunctionWrapped","addNonEnumerableProperty","defineProperty","writable","configurable","o_O","proto","getOriginalFunction","func","__sentry_original__","convertToPlainObject","getOwnProperties","newObj","serializeEventTarget","currentTarget","CustomEvent","detail","extractedProps","property","extractExceptionKeysForMessage","maxLength","firstKey","includedKeys","serialized","dropUndefinedKeys","inputValue","_dropUndefinedKeys","memoizationMap","e2","isPojo","memoVal","returnValue","getOwnPropertyNames","normalizeArray","allowAboveRoot","up","last","splitPathRe","splitPath","truncated","resolvedPath","resolvedAbsolute","charAt","p","arr","start","relative","to","fromParts","toParts","samePartsLength","outputParts","concat","basename","ext","f","generateTraceId","generateSpanId","substring","DEFAULT_RETRY_AFTER","parseRetryAfterHeader","now","headerDelay","headerDate","isRateLimited","limits","disabledUntil","updateRateLimits","updatedRateLimits","rateLimitHeader","retryAfterHeader","retryAfter","categories","namespaces","category","severityLevelFromString","STACKTRACE_FRAME_LIMIT","UNKNOWN_FUNCTION","WEBPACK_ERROR_REGEXP","STRIP_FRAME_REGEXP","createStackParser","parsers","sortedParsers","skipFirstLines","framesToPop","frames","cleanedLine","localStack","getLastStackFrame","function","stripSentryFramesAndReverse","stackParserFromStackParserOptions","defaultFunctionName","getFunctionName","getFramesFromEvent","stacktrace","truncate","snipLine","newLine","lineLength","safeJoin","delimiter","output","stringMatchesSomePattern","testString","patterns","requireExactStringMatch","some","pattern","isMatchingPattern","supportsFetch","Headers","Request","Response","isNativeFunction","supportsNativeFetch","EdgeRuntime","fetch","doc","sandbox","createElement","hidden","head","appendChild","contentWindow","removeChild","supportsReportingObserver","States","resolvedSyncPromise","SyncPromise","rejectedSyncPromise","executor","__init","__init2","__init3","__init4","_state","PENDING","_handlers","_resolve","_reject","onfulfilled","onrejected","_executeHandlers","val","onfinally","isRejected","_setResult","RESOLVED","REJECTED","state","cachedHandlers","ONE_SECOND_IN_MS","dateTimestampInSeconds","timestampInSeconds","performance","approxStartingTimeOrigin","timeOrigin","createUnixTimestampInSecondsFunc","_browserPerformanceTimeOriginMode","browserPerformanceTimeOrigin","threshold","performanceNow","dateNow","timeOriginDelta","abs","timeOriginIsReliable","navigationStart","timing","navigationStartDelta","TRACEPARENT_REGEXP","RegExp","propagationContextFromHeaders","traceparentData","traceparent","matches","extractTraceparentData","generateSentryTraceHeader","sampledString","parseUrl","query","fragment","search","hash","stripUrlQueryAndFragment","urlPath","supportsHistory","chromeVar","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","history","pushState","replaceState","SDK_VERSION","GLOBAL_OBJ","globalThis","getGlobalSingleton","creator","versionedCarrier","onError","onFinally","maybePromiseResult","maybeHandlePromiseRejection","maybeOptions","__SENTRY_TRACING__","enableTracing","isSentryRequestUrl","checkDsn","removeTrailingSlash","checkTunnel","merge","initialObj","mergeObj","levels","parameterize","strings","formatted","raw","__sentry_template_string__","__sentry_template_values__","rate","parseFloat","applyScopeDataToEvent","fingerprint","breadcrumbs","extra","tags","user","transactionName","cleanedExtra","cleanedTags","cleanedUser","cleanedContexts","applyDataToEvent","applySpanToEvent","applyFingerprintToEvent","mergedBreadcrumbs","applyBreadcrumbsToEvent","applySdkMetadataToEvent","mergeScopeData","mergeData","eventProcessors","attachments","mergeAndOverwriteScopeData","mergeVal","prepareEvent","normalizeDepth","normalizeMaxBreadth","prepared","integrations","dist","request","applyClientOptions","integrationNames","applyIntegrationsMetadata","applyDebugIds","finalScope","captureContext","update","getFinalScope","clientEventProcessors","getEventProcessors","evt","abs_path","debug_meta","applyDebugMeta","maxBreadth","flags","normalizeEvent","parseEventHintOrCaptureContext","hintIsScopeOrFunction","captureContextKeys","hintIsScopeContext","applySdkMetadata","names","metadata","_metadata","packages","SCOPE_SPAN_FIELD","_setSpanForScope","_getSpanForScope","TRACE_FLAG_NONE","TRACE_FLAG_SAMPLED","hasShownSpanDropWarning","spanToTransactionTraceContext","spanToJSON","spanToTraceContext","isRemote","spanToTraceHeader","spanIsSampled","spanTimeInputToSeconds","ensureTimestampInSeconds","getTime","spanIsSentrySpan","castSpan","endTime","spanIsOpenTelemetrySdkTraceBaseSpan","getStatusMessage","CHILD_SPANS_FIELD","ROOT_SPAN_FIELD","addChildSpanToSpan","Set","removeChildSpanFromSpan","getSpanDescendants","resultSet","addSpanChildren","getRootSpan","getActiveSpan","updateMetricSummaryOnActiveSpan","metricType","sanitizedName","bucketKey","showSpanDropWarning","getTraceData","scopeToTraceHeader"],"sourceRoot":""}