{"version":3,"file":"sentryConfig-051ab600.js","sources":["../../node_modules/@sentry/core/build/esm/tracing/errors.js","../../node_modules/@sentry/core/build/esm/tracing/idleSpan.js","../../node_modules/@sentry/core/build/esm/utils/traceData.js","../../node_modules/@sentry/core/build/esm/metadata.js","../../node_modules/@sentry/core/build/esm/integrations/third-party-errors-filter.js","../../node_modules/@sentry/core/build/esm/fetch.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/bindReporter.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/generateUniqueID.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/getNavigationEntry.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/getActivationStart.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/initMetric.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/observe.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/onHidden.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/runOnce.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/getVisibilityWatcher.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/whenActivated.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/onFCP.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/getCLS.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/getFID.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/polyfills/interactionCountPolyfill.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/interactions.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/whenIdle.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/getINP.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/getLCP.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/onTTFB.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/instrument.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/utils.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/cls.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/browserMetrics.js","../../node_modules/@sentry-internal/browser-utils/build/esm/metrics/inp.js","../../node_modules/@sentry/browser/build/npm/esm/tracing/request.js","../../node_modules/@sentry/browser/build/npm/esm/tracing/backgroundtab.js","../../node_modules/@sentry/browser/build/npm/esm/tracing/browserTracingIntegration.js","../../node_modules/@sentry/vue/build/esm/router.js","../../node_modules/@sentry/vue/build/esm/browserTracingIntegration.js","../../client/packages/shared/plugins/flipper/index.ts","../../client/packages/config/sentryConfig.ts"],"sourcesContent":["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 { 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 { hasSpansEnabled } from '../utils/hasSpansEnabled.js';\nimport { _setSpanForScope } from '../utils/spanOnScope.js';\nimport { getActiveSpan, spanTimeInputToSeconds, getSpanDescendants, spanToJSON, removeChildSpanFromSpan } from '../utils/spanUtils.js';\nimport { getDynamicSamplingContextFromSpan, freezeDscOnSpan } from './dynamicSamplingContext.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 || !hasSpansEnabled()) {\n    const span = new SentryNonRecordingSpan();\n\n    const dsc = {\n      sample_rate: '0',\n      sampled: 'false',\n      ...getDynamicSamplingContextFromSpan(span),\n    } ;\n    freezeDscOnSpan(span, dsc);\n\n    return span;\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      // If the span is non-recording, nothing more to do here...\n      // This is the case if tracing is enabled but this specific span was not sampled\n      if (thisArg instanceof SentryNonRecordingSpan) {\n        return;\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 { 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/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 { getDynamicSamplingContextFromSpan, getDynamicSamplingContextFromScope } from '../tracing/dynamicSamplingContext.js';\nimport { TRACEPARENT_REGEXP, generateSentryTraceHeader } from '../utils-hoist/tracing.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  const { traceId, sampled, propagationSpanId } = scope.getPropagationContext();\n  return generateSentryTraceHeader(traceId, propagationSpanId, sampled);\n}\n\nexport { getTraceData };\n//# sourceMappingURL=traceData.js.map\n","import { GLOBAL_OBJ } from './utils-hoist/worldwide.js';\n\n/** Keys are source filename/url, values are metadata objects. */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst filenameMetadataMap = new Map();\n/** Set of stack strings that have already been parsed. */\nconst parsedStacks = new Set();\n\nfunction ensureMetadataStacksAreParsed(parser) {\n  if (!GLOBAL_OBJ._sentryModuleMetadata) {\n    return;\n  }\n\n  for (const stack of Object.keys(GLOBAL_OBJ._sentryModuleMetadata)) {\n    const metadata = GLOBAL_OBJ._sentryModuleMetadata[stack];\n\n    if (parsedStacks.has(stack)) {\n      continue;\n    }\n\n    // Ensure this stack doesn't get parsed again\n    parsedStacks.add(stack);\n\n    const frames = parser(stack);\n\n    // Go through the frames starting from the top of the stack and find the first one with a filename\n    for (const frame of frames.reverse()) {\n      if (frame.filename) {\n        // Save the metadata for this filename\n        filenameMetadataMap.set(frame.filename, metadata);\n        break;\n      }\n    }\n  }\n}\n\n/**\n * Retrieve metadata for a specific JavaScript file URL.\n *\n * Metadata is injected by the Sentry bundler plugins using the `_experiments.moduleMetadata` config option.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction getMetadataForUrl(parser, filename) {\n  ensureMetadataStacksAreParsed(parser);\n  return filenameMetadataMap.get(filename);\n}\n\n/**\n * Adds metadata to stack frames.\n *\n * Metadata is injected by the Sentry bundler plugins using the `_experiments.moduleMetadata` config option.\n */\nfunction addMetadataToStackFrames(parser, event) {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    event.exception.values.forEach(exception => {\n      if (!exception.stacktrace) {\n        return;\n      }\n\n      for (const frame of exception.stacktrace.frames || []) {\n        if (!frame.filename || frame.module_metadata) {\n          continue;\n        }\n\n        const metadata = getMetadataForUrl(parser, frame.filename);\n\n        if (metadata) {\n          frame.module_metadata = metadata;\n        }\n      }\n    });\n  } catch (_) {\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 * Strips metadata from stack frames.\n */\nfunction stripMetadataFromStackFrames(event) {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    event.exception.values.forEach(exception => {\n      if (!exception.stacktrace) {\n        return;\n      }\n\n      for (const frame of exception.stacktrace.frames || []) {\n        delete frame.module_metadata;\n      }\n    });\n  } catch (_) {\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\nexport { addMetadataToStackFrames, getMetadataForUrl, stripMetadataFromStackFrames };\n//# sourceMappingURL=metadata.js.map\n","import { defineIntegration } from '../integration.js';\nimport { stripMetadataFromStackFrames, addMetadataToStackFrames } from '../metadata.js';\nimport { forEachEnvelopeItem } from '../utils-hoist/envelope.js';\nimport { getFramesFromEvent } from '../utils-hoist/stacktrace.js';\n\n/**\n * This integration allows you to filter out, or tag error events that do not come from user code marked with a bundle key via the Sentry bundler plugins.\n */\nconst thirdPartyErrorFilterIntegration = defineIntegration((options) => {\n  return {\n    name: 'ThirdPartyErrorsFilter',\n    setup(client) {\n      // We need to strip metadata from stack frames before sending them to Sentry since these are client side only.\n      // TODO(lforst): Move this cleanup logic into a more central place in the SDK.\n      client.on('beforeEnvelope', envelope => {\n        forEachEnvelopeItem(envelope, (item, type) => {\n          if (type === 'event') {\n            const event = Array.isArray(item) ? (item )[1] : undefined;\n\n            if (event) {\n              stripMetadataFromStackFrames(event);\n              item[1] = event;\n            }\n          }\n        });\n      });\n\n      client.on('applyFrameMetadata', event => {\n        // Only apply stack frame metadata to error events\n        if (event.type) {\n          return;\n        }\n\n        const stackParser = client.getOptions().stackParser;\n        addMetadataToStackFrames(stackParser, event);\n      });\n    },\n\n    processEvent(event) {\n      const frameKeys = getBundleKeysForAllFramesWithFilenames(event);\n\n      if (frameKeys) {\n        const arrayMethod =\n          options.behaviour === 'drop-error-if-contains-third-party-frames' ||\n          options.behaviour === 'apply-tag-if-contains-third-party-frames'\n            ? 'some'\n            : 'every';\n\n        const behaviourApplies = frameKeys[arrayMethod](keys => !keys.some(key => options.filterKeys.includes(key)));\n\n        if (behaviourApplies) {\n          const shouldDrop =\n            options.behaviour === 'drop-error-if-contains-third-party-frames' ||\n            options.behaviour === 'drop-error-if-exclusively-contains-third-party-frames';\n          if (shouldDrop) {\n            return null;\n          } else {\n            event.tags = {\n              ...event.tags,\n              third_party_code: true,\n            };\n          }\n        }\n      }\n\n      return event;\n    },\n  };\n});\n\nfunction getBundleKeysForAllFramesWithFilenames(event) {\n  const frames = getFramesFromEvent(event);\n\n  if (!frames) {\n    return undefined;\n  }\n\n  return (\n    frames\n      // Exclude frames without a filename since these are likely native code or built-ins\n      .filter(frame => !!frame.filename)\n      .map(frame => {\n        if (frame.module_metadata) {\n          return Object.keys(frame.module_metadata)\n            .filter(key => key.startsWith(BUNDLER_PLUGIN_APP_KEY_PREFIX))\n            .map(key => key.slice(BUNDLER_PLUGIN_APP_KEY_PREFIX.length));\n        }\n        return [];\n      })\n  );\n}\n\nconst BUNDLER_PLUGIN_APP_KEY_PREFIX = '_sentryBundlerPluginAppKey:';\n\nexport { thirdPartyErrorFilterIntegration };\n//# sourceMappingURL=third-party-errors-filter.js.map\n","import { getClient } from './currentScopes.js';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_OP } from './semanticAttributes.js';\nimport './tracing/errors.js';\nimport { isInstanceOf } from './utils-hoist/is.js';\nimport './utils-hoist/debug-build.js';\nimport './utils-hoist/logger.js';\nimport './debug-build.js';\nimport './utils-hoist/time.js';\nimport { hasSpansEnabled } from './utils/hasSpansEnabled.js';\nimport { getActiveSpan } from './utils/spanUtils.js';\nimport { SENTRY_BAGGAGE_KEY_PREFIX } from './utils-hoist/baggage.js';\nimport { SentryNonRecordingSpan } from './tracing/sentryNonRecordingSpan.js';\nimport { setHttpStatus, SPAN_STATUS_ERROR } from './tracing/spanstatus.js';\nimport { startInactiveSpan } from './tracing/trace.js';\nimport { parseUrl } from './utils-hoist/url.js';\nimport { getTraceData } from './utils/traceData.js';\n\n/**\n * Create and track fetch request spans for usage in combination with `addFetchInstrumentationHandler`.\n *\n * @returns Span if a span was created, otherwise void.\n */\nfunction instrumentFetchRequest(\n  handlerData,\n  shouldCreateSpan,\n  shouldAttachHeaders,\n  spans,\n  spanOrigin = 'auto.http.browser',\n) {\n  if (!handlerData.fetchData) {\n    return undefined;\n  }\n\n  const shouldCreateSpanResult = hasSpansEnabled() && shouldCreateSpan(handlerData.fetchData.url);\n\n  if (handlerData.endTimestamp && shouldCreateSpanResult) {\n    const spanId = handlerData.fetchData.__span;\n    if (!spanId) return;\n\n    const span = spans[spanId];\n    if (span) {\n      endSpan(span, handlerData);\n\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete spans[spanId];\n    }\n    return undefined;\n  }\n\n  const { method, url } = handlerData.fetchData;\n\n  const fullUrl = getFullURL(url);\n  const host = fullUrl ? parseUrl(fullUrl).host : undefined;\n\n  const hasParent = !!getActiveSpan();\n\n  const span =\n    shouldCreateSpanResult && hasParent\n      ? startInactiveSpan({\n          name: `${method} ${url}`,\n          attributes: {\n            url,\n            type: 'fetch',\n            'http.method': method,\n            'http.url': fullUrl,\n            'server.address': host,\n            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: spanOrigin,\n            [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.client',\n          },\n        })\n      : new SentryNonRecordingSpan();\n\n  handlerData.fetchData.__span = span.spanContext().spanId;\n  spans[span.spanContext().spanId] = span;\n\n  if (shouldAttachHeaders(handlerData.fetchData.url)) {\n    const request = handlerData.args[0];\n\n    const options = handlerData.args[1] || {};\n\n    const headers = _addTracingHeadersToFetchRequest(\n      request,\n      options,\n      // If performance is disabled (TWP) or there's no active root span (pageload/navigation/interaction),\n      // we do not want to use the span as base for the trace headers,\n      // which means that the headers will be generated from the scope and the sampling decision is deferred\n      hasSpansEnabled() && hasParent ? span : undefined,\n    );\n    if (headers) {\n      // Ensure this is actually set, if no options have been passed previously\n      handlerData.args[1] = options;\n      options.headers = headers;\n    }\n  }\n\n  const client = getClient();\n\n  if (client) {\n    const fetchHint = {\n      input: handlerData.args,\n      response: handlerData.response,\n      startTimestamp: handlerData.startTimestamp,\n      endTimestamp: handlerData.endTimestamp,\n    } ;\n\n    client.emit('beforeOutgoingRequestSpan', span, fetchHint);\n  }\n\n  return span;\n}\n\n/**\n * Adds sentry-trace and baggage headers to the various forms of fetch headers.\n */\nfunction _addTracingHeadersToFetchRequest(\n  request,\n  fetchOptionsObj\n\n,\n  span,\n) {\n  const traceHeaders = getTraceData({ span });\n  const sentryTrace = traceHeaders['sentry-trace'];\n  const baggage = traceHeaders.baggage;\n\n  // Nothing to do, when we return undefined here, the original headers will be used\n  if (!sentryTrace) {\n    return undefined;\n  }\n\n  const headers = fetchOptionsObj.headers || (isRequest(request) ? request.headers : undefined);\n\n  if (!headers) {\n    return { ...traceHeaders };\n  } else if (isHeaders(headers)) {\n    const newHeaders = new Headers(headers);\n    newHeaders.set('sentry-trace', sentryTrace);\n\n    if (baggage) {\n      const prevBaggageHeader = newHeaders.get('baggage');\n      if (prevBaggageHeader) {\n        const prevHeaderStrippedFromSentryBaggage = stripBaggageHeaderOfSentryBaggageValues(prevBaggageHeader);\n        newHeaders.set(\n          'baggage',\n          // If there are non-sentry entries (i.e. if the stripped string is non-empty/truthy) combine the stripped header and sentry baggage header\n          // otherwise just set the sentry baggage header\n          prevHeaderStrippedFromSentryBaggage ? `${prevHeaderStrippedFromSentryBaggage},${baggage}` : baggage,\n        );\n      } else {\n        newHeaders.set('baggage', baggage);\n      }\n    }\n\n    return newHeaders;\n  } else if (Array.isArray(headers)) {\n    const newHeaders = [\n      ...headers\n        // Remove any existing sentry-trace headers\n        .filter(header => {\n          return !(Array.isArray(header) && header[0] === 'sentry-trace');\n        })\n        // Get rid of previous sentry baggage values in baggage header\n        .map(header => {\n          if (Array.isArray(header) && header[0] === 'baggage' && typeof header[1] === 'string') {\n            const [headerName, headerValue, ...rest] = header;\n            return [headerName, stripBaggageHeaderOfSentryBaggageValues(headerValue), ...rest];\n          } else {\n            return header;\n          }\n        }),\n      // Attach the new sentry-trace header\n      ['sentry-trace', sentryTrace],\n    ];\n\n    if (baggage) {\n      // If there are multiple entries with the same key, the browser will merge the values into a single request header.\n      // Its therefore safe to simply push a \"baggage\" entry, even though there might already be another baggage header.\n      newHeaders.push(['baggage', baggage]);\n    }\n\n    return newHeaders ;\n  } else {\n    const existingBaggageHeader = 'baggage' in headers ? headers.baggage : undefined;\n    let newBaggageHeaders = [];\n\n    if (Array.isArray(existingBaggageHeader)) {\n      newBaggageHeaders = existingBaggageHeader\n        .map(headerItem =>\n          typeof headerItem === 'string' ? stripBaggageHeaderOfSentryBaggageValues(headerItem) : headerItem,\n        )\n        .filter(headerItem => headerItem === '');\n    } else if (existingBaggageHeader) {\n      newBaggageHeaders.push(stripBaggageHeaderOfSentryBaggageValues(existingBaggageHeader));\n    }\n\n    if (baggage) {\n      newBaggageHeaders.push(baggage);\n    }\n\n    return {\n      ...(headers ),\n      'sentry-trace': sentryTrace,\n      baggage: newBaggageHeaders.length > 0 ? newBaggageHeaders.join(',') : undefined,\n    };\n  }\n}\n\nfunction getFullURL(url) {\n  try {\n    const parsed = new URL(url);\n    return parsed.href;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction endSpan(span, handlerData) {\n  if (handlerData.response) {\n    setHttpStatus(span, handlerData.response.status);\n\n    const contentLength = handlerData.response?.headers && handlerData.response.headers.get('content-length');\n\n    if (contentLength) {\n      const contentLengthNum = parseInt(contentLength);\n      if (contentLengthNum > 0) {\n        span.setAttribute('http.response_content_length', contentLengthNum);\n      }\n    }\n  } else if (handlerData.error) {\n    span.setStatus({ code: SPAN_STATUS_ERROR, message: 'internal_error' });\n  }\n  span.end();\n}\n\nfunction stripBaggageHeaderOfSentryBaggageValues(baggageHeader) {\n  return (\n    baggageHeader\n      .split(',')\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      .filter(baggageEntry => !baggageEntry.split('=')[0].startsWith(SENTRY_BAGGAGE_KEY_PREFIX))\n      .join(',')\n  );\n}\n\nfunction isRequest(request) {\n  return typeof Request !== 'undefined' && isInstanceOf(request, Request);\n}\n\nfunction isHeaders(headers) {\n  return typeof Headers !== 'undefined' && isInstanceOf(headers, Headers);\n}\n\nexport { instrumentFetchRequest };\n//# sourceMappingURL=fetch.js.map\n","const getRating = (value, thresholds) => {\n  if (value > thresholds[1]) {\n    return 'poor';\n  }\n  if (value > thresholds[0]) {\n    return 'needs-improvement';\n  }\n  return 'good';\n};\n\nconst bindReporter = (\n  callback,\n  metric,\n  thresholds,\n  reportAllChanges,\n) => {\n  let prevValue;\n  let delta;\n  return (forceReport) => {\n    if (metric.value >= 0) {\n      if (forceReport || reportAllChanges) {\n        delta = metric.value - (prevValue || 0);\n\n        // Report the metric if there's a non-zero delta or if no previous\n        // value exists (which can happen in the case of the document becoming\n        // hidden when the metric value is 0).\n        // See: https://github.com/GoogleChrome/web-vitals/issues/14\n        if (delta || prevValue === undefined) {\n          prevValue = metric.value;\n          metric.delta = delta;\n          metric.rating = getRating(metric.value, thresholds);\n          callback(metric);\n        }\n      }\n    }\n  };\n};\n\nexport { bindReporter };\n//# sourceMappingURL=bindReporter.js.map\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Performantly generate a unique, 30-char string by combining a version\n * number, the current timestamp with a 13-digit number integer.\n * @return {string}\n */\nconst generateUniqueID = () => {\n  return `v4-${Date.now()}-${Math.floor(Math.random() * (9e12 - 1)) + 1e12}`;\n};\n\nexport { generateUniqueID };\n//# sourceMappingURL=generateUniqueID.js.map\n","import { WINDOW } from '../../../types.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n// sentry-specific change:\n// add optional param to not check for responseStart (see comment below)\nconst getNavigationEntry = (checkResponseStart = true) => {\n  const navigationEntry = WINDOW.performance?.getEntriesByType?.('navigation')[0];\n  // Check to ensure the `responseStart` property is present and valid.\n  // In some cases no value is reported by the browser (for\n  // privacy/security reasons), and in other cases (bugs) the value is\n  // negative or is larger than the current page time. Ignore these cases:\n  // https://github.com/GoogleChrome/web-vitals/issues/137\n  // https://github.com/GoogleChrome/web-vitals/issues/162\n  // https://github.com/GoogleChrome/web-vitals/issues/275\n  if (\n    // sentry-specific change:\n    // We don't want to check for responseStart for our own use of `getNavigationEntry`\n    !checkResponseStart ||\n    (navigationEntry && navigationEntry.responseStart > 0 && navigationEntry.responseStart < performance.now())\n  ) {\n    return navigationEntry;\n  }\n};\n\nexport { getNavigationEntry };\n//# sourceMappingURL=getNavigationEntry.js.map\n","import { getNavigationEntry } from './getNavigationEntry.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nconst getActivationStart = () => {\n  const navEntry = getNavigationEntry();\n  return navEntry?.activationStart || 0;\n};\n\nexport { getActivationStart };\n//# sourceMappingURL=getActivationStart.js.map\n","import { WINDOW } from '../../../types.js';\nimport { generateUniqueID } from './generateUniqueID.js';\nimport { getActivationStart } from './getActivationStart.js';\nimport { getNavigationEntry } from './getNavigationEntry.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nconst initMetric = (name, value) => {\n  const navEntry = getNavigationEntry();\n  let navigationType = 'navigate';\n\n  if (navEntry) {\n    if (WINDOW.document?.prerendering || getActivationStart() > 0) {\n      navigationType = 'prerender';\n    } else if (WINDOW.document?.wasDiscarded) {\n      navigationType = 'restore';\n    } else if (navEntry.type) {\n      navigationType = navEntry.type.replace(/_/g, '-') ;\n    }\n  }\n\n  // Use `entries` type specific for the metric.\n  const entries = [];\n\n  return {\n    name,\n    value: typeof value === 'undefined' ? -1 : value,\n    rating: 'good' , // If needed, will be updated when reported. `const` to keep the type from widening to `string`.\n    delta: 0,\n    entries,\n    id: generateUniqueID(),\n    navigationType,\n  };\n};\n\nexport { initMetric };\n//# sourceMappingURL=initMetric.js.map\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Takes a performance entry type and a callback function, and creates a\n * `PerformanceObserver` instance that will observe the specified entry type\n * with buffering enabled and call the callback _for each entry_.\n *\n * This function also feature-detects entry support and wraps the logic in a\n * try/catch to avoid errors in unsupporting browsers.\n */\nconst observe = (\n  type,\n  callback,\n  opts,\n) => {\n  try {\n    if (PerformanceObserver.supportedEntryTypes.includes(type)) {\n      const po = new PerformanceObserver(list => {\n        // Delay by a microtask to workaround a bug in Safari where the\n        // callback is invoked immediately, rather than in a separate task.\n        // See: https://github.com/GoogleChrome/web-vitals/issues/277\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        Promise.resolve().then(() => {\n          callback(list.getEntries() );\n        });\n      });\n      po.observe(\n        Object.assign(\n          {\n            type,\n            buffered: true,\n          },\n          opts || {},\n        ) ,\n      );\n      return po;\n    }\n  } catch (e) {\n    // Do nothing.\n  }\n  return;\n};\n\nexport { observe };\n//# sourceMappingURL=observe.js.map\n","import { WINDOW } from '../../../types.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n// Sentry-specific change:\n// This function's logic was NOT updated to web-vitals 4.2.4 but we continue\n// to use the web-vitals 3.5.2 due to us having stricter browser support.\n// PR with context that made the changes: https://github.com/GoogleChrome/web-vitals/pull/442/files#r1530492402\n// The PR removed listening to the `pagehide` event, in favour of only listening to `visibilitychange` event.\n// This is \"more correct\" but some browsers we still support (Safari 12.1-14.0) don't fully support `visibilitychange`\n// or have known bugs w.r.t the `visibilitychange` event.\n// TODO (v9): If we decide to drop support for Safari 12.1-14.0, we can use the logic from web-vitals 4.2.4\n// In this case, we also need to update the integration tests that currently trigger the `pagehide` event to\n// simulate the page being hidden.\nconst onHidden = (cb) => {\n  const onHiddenOrPageHide = (event) => {\n    if (event.type === 'pagehide' || WINDOW.document?.visibilityState === 'hidden') {\n      cb(event);\n    }\n  };\n\n  if (WINDOW.document) {\n    addEventListener('visibilitychange', onHiddenOrPageHide, true);\n    // Some browsers have buggy implementations of visibilitychange,\n    // so we use pagehide in addition, just to be safe.\n    addEventListener('pagehide', onHiddenOrPageHide, true);\n  }\n};\n\nexport { onHidden };\n//# sourceMappingURL=onHidden.js.map\n","/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst runOnce = (cb) => {\n  let called = false;\n  return () => {\n    if (!called) {\n      cb();\n      called = true;\n    }\n  };\n};\n\nexport { runOnce };\n//# sourceMappingURL=runOnce.js.map\n","import { WINDOW } from '../../../types.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nlet firstHiddenTime = -1;\n\nconst initHiddenTime = () => {\n  // If the document is hidden when this code runs, assume it was always\n  // hidden and the page was loaded in the background, with the one exception\n  // that visibility state is always 'hidden' during prerendering, so we have\n  // to ignore that case until prerendering finishes (see: `prerenderingchange`\n  // event logic below).\n  return WINDOW.document.visibilityState === 'hidden' && !WINDOW.document.prerendering ? 0 : Infinity;\n};\n\nconst onVisibilityUpdate = (event) => {\n  // If the document is 'hidden' and no previous hidden timestamp has been\n  // set, update it based on the current event data.\n  if (WINDOW.document.visibilityState === 'hidden' && firstHiddenTime > -1) {\n    // If the event is a 'visibilitychange' event, it means the page was\n    // visible prior to this change, so the event timestamp is the first\n    // hidden time.\n    // However, if the event is not a 'visibilitychange' event, then it must\n    // be a 'prerenderingchange' event, and the fact that the document is\n    // still 'hidden' from the above check means the tab was activated\n    // in a background state and so has always been hidden.\n    firstHiddenTime = event.type === 'visibilitychange' ? event.timeStamp : 0;\n\n    // Remove all listeners now that a `firstHiddenTime` value has been set.\n    removeChangeListeners();\n  }\n};\n\nconst addChangeListeners = () => {\n  addEventListener('visibilitychange', onVisibilityUpdate, true);\n  // IMPORTANT: when a page is prerendering, its `visibilityState` is\n  // 'hidden', so in order to account for cases where this module checks for\n  // visibility during prerendering, an additional check after prerendering\n  // completes is also required.\n  addEventListener('prerenderingchange', onVisibilityUpdate, true);\n};\n\nconst removeChangeListeners = () => {\n  removeEventListener('visibilitychange', onVisibilityUpdate, true);\n  removeEventListener('prerenderingchange', onVisibilityUpdate, true);\n};\n\nconst getVisibilityWatcher = () => {\n  if (WINDOW.document && firstHiddenTime < 0) {\n    // If the document is hidden when this code runs, assume it was hidden\n    // since navigation start. This isn't a perfect heuristic, but it's the\n    // best we can do until an API is available to support querying past\n    // visibilityState.\n    firstHiddenTime = initHiddenTime();\n    addChangeListeners();\n  }\n  return {\n    get firstHiddenTime() {\n      return firstHiddenTime;\n    },\n  };\n};\n\nexport { getVisibilityWatcher };\n//# sourceMappingURL=getVisibilityWatcher.js.map\n","import { WINDOW } from '../../../types.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nconst whenActivated = (callback) => {\n  if (WINDOW.document?.prerendering) {\n    addEventListener('prerenderingchange', () => callback(), true);\n  } else {\n    callback();\n  }\n};\n\nexport { whenActivated };\n//# sourceMappingURL=whenActivated.js.map\n","import { bindReporter } from './lib/bindReporter.js';\nimport { getActivationStart } from './lib/getActivationStart.js';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { whenActivated } from './lib/whenActivated.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** Thresholds for FCP. See https://web.dev/articles/fcp#what_is_a_good_fcp_score */\nconst FCPThresholds = [1800, 3000];\n\n/**\n * Calculates the [FCP](https://web.dev/articles/fcp) value for the current page and\n * calls the `callback` function once the value is ready, along with the\n * relevant `paint` performance entry used to determine the value. The reported\n * value is a `DOMHighResTimeStamp`.\n */\nconst onFCP = (onReport, opts = {}) => {\n  whenActivated(() => {\n    const visibilityWatcher = getVisibilityWatcher();\n    const metric = initMetric('FCP');\n    let report;\n\n    const handleEntries = (entries) => {\n      entries.forEach(entry => {\n        if (entry.name === 'first-contentful-paint') {\n          po.disconnect();\n\n          // Only report if the page wasn't hidden prior to the first paint.\n          if (entry.startTime < visibilityWatcher.firstHiddenTime) {\n            // The activationStart reference is used because FCP should be\n            // relative to page activation rather than navigation start if the\n            // page was prerendered. But in cases where `activationStart` occurs\n            // after the FCP, this time should be clamped at 0.\n            metric.value = Math.max(entry.startTime - getActivationStart(), 0);\n            metric.entries.push(entry);\n            report(true);\n          }\n        }\n      });\n    };\n\n    const po = observe('paint', handleEntries);\n\n    if (po) {\n      report = bindReporter(onReport, metric, FCPThresholds, opts.reportAllChanges);\n    }\n  });\n};\n\nexport { FCPThresholds, onFCP };\n//# sourceMappingURL=onFCP.js.map\n","import { bindReporter } from './lib/bindReporter.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\nimport { runOnce } from './lib/runOnce.js';\nimport { onFCP } from './onFCP.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** Thresholds for CLS. See https://web.dev/articles/cls#what_is_a_good_cls_score */\nconst CLSThresholds = [0.1, 0.25];\n\n/**\n * Calculates the [CLS](https://web.dev/articles/cls) value for the current page and\n * calls the `callback` function once the value is ready to be reported, along\n * with all `layout-shift` performance entries that were used in the metric\n * value calculation. The reported value is a `double` (corresponding to a\n * [layout shift score](https://web.dev/articles/cls#layout_shift_score)).\n *\n * If the `reportAllChanges` configuration option is set to `true`, the\n * `callback` function will be called as soon as the value is initially\n * determined as well as any time the value changes throughout the page\n * lifespan.\n *\n * _**Important:** CLS should be continually monitored for changes throughout\n * the entire lifespan of a page—including if the user returns to the page after\n * it's been hidden/backgrounded. However, since browsers often [will not fire\n * additional callbacks once the user has backgrounded a\n * page](https://developer.chrome.com/blog/page-lifecycle-api/#advice-hidden),\n * `callback` is always called when the page's visibility state changes to\n * hidden. As a result, the `callback` function might be called multiple times\n * during the same page load._\n */\nconst onCLS = (onReport, opts = {}) => {\n  // Start monitoring FCP so we can only report CLS if FCP is also reported.\n  // Note: this is done to match the current behavior of CrUX.\n  onFCP(\n    runOnce(() => {\n      const metric = initMetric('CLS', 0);\n      let report;\n\n      let sessionValue = 0;\n      let sessionEntries = [];\n\n      const handleEntries = (entries) => {\n        entries.forEach(entry => {\n          // Only count layout shifts without recent user input.\n          if (!entry.hadRecentInput) {\n            const firstSessionEntry = sessionEntries[0];\n            const lastSessionEntry = sessionEntries[sessionEntries.length - 1];\n\n            // If the entry occurred less than 1 second after the previous entry\n            // and less than 5 seconds after the first entry in the session,\n            // include the entry in the current session. Otherwise, start a new\n            // session.\n            if (\n              sessionValue &&\n              firstSessionEntry &&\n              lastSessionEntry &&\n              entry.startTime - lastSessionEntry.startTime < 1000 &&\n              entry.startTime - firstSessionEntry.startTime < 5000\n            ) {\n              sessionValue += entry.value;\n              sessionEntries.push(entry);\n            } else {\n              sessionValue = entry.value;\n              sessionEntries = [entry];\n            }\n          }\n        });\n\n        // If the current session value is larger than the current CLS value,\n        // update CLS and the entries contributing to it.\n        if (sessionValue > metric.value) {\n          metric.value = sessionValue;\n          metric.entries = sessionEntries;\n          report();\n        }\n      };\n\n      const po = observe('layout-shift', handleEntries);\n      if (po) {\n        report = bindReporter(onReport, metric, CLSThresholds, opts.reportAllChanges);\n\n        onHidden(() => {\n          handleEntries(po.takeRecords() );\n          report(true);\n        });\n\n        // Queue a task to report (if nothing else triggers a report first).\n        // This allows CLS to be reported as soon as FCP fires when\n        // `reportAllChanges` is true.\n        setTimeout(report, 0);\n      }\n    }),\n  );\n};\n\nexport { CLSThresholds, onCLS };\n//# sourceMappingURL=getCLS.js.map\n","import { bindReporter } from './lib/bindReporter.js';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\nimport { runOnce } from './lib/runOnce.js';\nimport { whenActivated } from './lib/whenActivated.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** Thresholds for FID. See https://web.dev/articles/fid#what_is_a_good_fid_score */\nconst FIDThresholds = [100, 300];\n\n/**\n * Calculates the [FID](https://web.dev/articles/fid) value for the current page and\n * calls the `callback` function once the value is ready, along with the\n * relevant `first-input` performance entry used to determine the value. The\n * reported value is a `DOMHighResTimeStamp`.\n *\n * _**Important:** since FID is only reported after the user interacts with the\n * page, it's possible that it will not be reported for some page loads._\n */\nconst onFID = (onReport, opts = {}) => {\n  whenActivated(() => {\n    const visibilityWatcher = getVisibilityWatcher();\n    const metric = initMetric('FID');\n    // eslint-disable-next-line prefer-const\n    let report;\n\n    const handleEntry = (entry) => {\n      // Only report if the page wasn't hidden prior to the first input.\n      if (entry.startTime < visibilityWatcher.firstHiddenTime) {\n        metric.value = entry.processingStart - entry.startTime;\n        metric.entries.push(entry);\n        report(true);\n      }\n    };\n\n    const handleEntries = (entries) => {\n      (entries ).forEach(handleEntry);\n    };\n\n    const po = observe('first-input', handleEntries);\n\n    report = bindReporter(onReport, metric, FIDThresholds, opts.reportAllChanges);\n\n    if (po) {\n      onHidden(\n        runOnce(() => {\n          handleEntries(po.takeRecords() );\n          po.disconnect();\n        }),\n      );\n    }\n  });\n};\n\nexport { FIDThresholds, onFID };\n//# sourceMappingURL=getFID.js.map\n","import { observe } from '../observe.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nlet interactionCountEstimate = 0;\nlet minKnownInteractionId = Infinity;\nlet maxKnownInteractionId = 0;\n\nconst updateEstimate = (entries) => {\n  entries.forEach(e => {\n    if (e.interactionId) {\n      minKnownInteractionId = Math.min(minKnownInteractionId, e.interactionId);\n      maxKnownInteractionId = Math.max(maxKnownInteractionId, e.interactionId);\n\n      interactionCountEstimate = maxKnownInteractionId ? (maxKnownInteractionId - minKnownInteractionId) / 7 + 1 : 0;\n    }\n  });\n};\n\nlet po;\n\n/**\n * Returns the `interactionCount` value using the native API (if available)\n * or the polyfill estimate in this module.\n */\nconst getInteractionCount = () => {\n  return po ? interactionCountEstimate : performance.interactionCount || 0;\n};\n\n/**\n * Feature detects native support or initializes the polyfill if needed.\n */\nconst initInteractionCountPolyfill = () => {\n  if ('interactionCount' in performance || po) return;\n\n  po = observe('event', updateEstimate, {\n    type: 'event',\n    buffered: true,\n    durationThreshold: 0,\n  } );\n};\n\nexport { getInteractionCount, initInteractionCountPolyfill };\n//# sourceMappingURL=interactionCountPolyfill.js.map\n","import { getInteractionCount } from './polyfills/interactionCountPolyfill.js';\n\n/*\n * Copyright 2024 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n// A list of longest interactions on the page (by latency) sorted so the\n// longest one is first. The list is at most MAX_INTERACTIONS_TO_CONSIDER long.\nconst longestInteractionList = [];\n\n// A mapping of longest interactions by their interaction ID.\n// This is used for faster lookup.\nconst longestInteractionMap = new Map();\n\n// The default `durationThreshold` used across this library for observing\n// `event` entries via PerformanceObserver.\nconst DEFAULT_DURATION_THRESHOLD = 40;\n\n// Used to store the interaction count after a bfcache restore, since p98\n// interaction latencies should only consider the current navigation.\nlet prevInteractionCount = 0;\n\n/**\n * Returns the interaction count since the last bfcache restore (or for the\n * full page lifecycle if there were no bfcache restores).\n */\nconst getInteractionCountForNavigation = () => {\n  return getInteractionCount() - prevInteractionCount;\n};\n\n/**\n * Returns the estimated p98 longest interaction based on the stored\n * interaction candidates and the interaction count for the current page.\n */\nconst estimateP98LongestInteraction = () => {\n  const candidateInteractionIndex = Math.min(\n    longestInteractionList.length - 1,\n    Math.floor(getInteractionCountForNavigation() / 50),\n  );\n\n  return longestInteractionList[candidateInteractionIndex];\n};\n\n// To prevent unnecessary memory usage on pages with lots of interactions,\n// store at most 10 of the longest interactions to consider as INP candidates.\nconst MAX_INTERACTIONS_TO_CONSIDER = 10;\n\n/**\n * A list of callback functions to run before each entry is processed.\n * Exposing this list allows the attribution build to hook into the\n * entry processing pipeline.\n */\nconst entryPreProcessingCallbacks = [];\n\n/**\n * Takes a performance entry and adds it to the list of worst interactions\n * if its duration is long enough to make it among the worst. If the\n * entry is part of an existing interaction, it is merged and the latency\n * and entries list is updated as needed.\n */\nconst processInteractionEntry = (entry) => {\n  entryPreProcessingCallbacks.forEach(cb => cb(entry));\n\n  // Skip further processing for entries that cannot be INP candidates.\n  if (!(entry.interactionId || entry.entryType === 'first-input')) return;\n\n  // The least-long of the 10 longest interactions.\n  const minLongestInteraction = longestInteractionList[longestInteractionList.length - 1];\n\n  const existingInteraction = longestInteractionMap.get(entry.interactionId);\n\n  // Only process the entry if it's possibly one of the ten longest,\n  // or if it's part of an existing interaction.\n  if (\n    existingInteraction ||\n    longestInteractionList.length < MAX_INTERACTIONS_TO_CONSIDER ||\n    (minLongestInteraction && entry.duration > minLongestInteraction.latency)\n  ) {\n    // If the interaction already exists, update it. Otherwise create one.\n    if (existingInteraction) {\n      // If the new entry has a longer duration, replace the old entries,\n      // otherwise add to the array.\n      if (entry.duration > existingInteraction.latency) {\n        existingInteraction.entries = [entry];\n        existingInteraction.latency = entry.duration;\n      } else if (\n        entry.duration === existingInteraction.latency &&\n        entry.startTime === existingInteraction.entries[0]?.startTime\n      ) {\n        existingInteraction.entries.push(entry);\n      }\n    } else {\n      const interaction = {\n        id: entry.interactionId,\n        latency: entry.duration,\n        entries: [entry],\n      };\n      longestInteractionMap.set(interaction.id, interaction);\n      longestInteractionList.push(interaction);\n    }\n\n    // Sort the entries by latency (descending) and keep only the top ten.\n    longestInteractionList.sort((a, b) => b.latency - a.latency);\n    if (longestInteractionList.length > MAX_INTERACTIONS_TO_CONSIDER) {\n      longestInteractionList.splice(MAX_INTERACTIONS_TO_CONSIDER).forEach(i => longestInteractionMap.delete(i.id));\n    }\n  }\n};\n\nexport { DEFAULT_DURATION_THRESHOLD, entryPreProcessingCallbacks, estimateP98LongestInteraction, longestInteractionList, longestInteractionMap, processInteractionEntry };\n//# sourceMappingURL=interactions.js.map\n","import { WINDOW } from '../../../types.js';\nimport { onHidden } from './onHidden.js';\nimport { runOnce } from './runOnce.js';\n\n/*\n * Copyright 2024 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/**\n * Runs the passed callback during the next idle period, or immediately\n * if the browser's visibility state is (or becomes) hidden.\n */\nconst whenIdle = (cb) => {\n  const rIC = WINDOW.requestIdleCallback || WINDOW.setTimeout;\n\n  let handle = -1;\n  // eslint-disable-next-line no-param-reassign\n  cb = runOnce(cb) ;\n  // If the document is hidden, run the callback immediately, otherwise\n  // race an idle callback with the next `visibilitychange` event.\n  if (WINDOW.document?.visibilityState === 'hidden') {\n    cb();\n  } else {\n    handle = rIC(cb);\n    onHidden(cb);\n  }\n  return handle;\n};\n\nexport { whenIdle };\n//# sourceMappingURL=whenIdle.js.map\n","import { WINDOW } from '../../types.js';\nimport { bindReporter } from './lib/bindReporter.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { DEFAULT_DURATION_THRESHOLD, processInteractionEntry, estimateP98LongestInteraction } from './lib/interactions.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\nimport { initInteractionCountPolyfill } from './lib/polyfills/interactionCountPolyfill.js';\nimport { whenActivated } from './lib/whenActivated.js';\nimport { whenIdle } from './lib/whenIdle.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** Thresholds for INP. See https://web.dev/articles/inp#what_is_a_good_inp_score */\nconst INPThresholds = [200, 500];\n\n/**\n * Calculates the [INP](https://web.dev/articles/inp) value for the current\n * page and calls the `callback` function once the value is ready, along with\n * the `event` performance entries reported for that interaction. The reported\n * value is a `DOMHighResTimeStamp`.\n *\n * A custom `durationThreshold` configuration option can optionally be passed to\n * control what `event-timing` entries are considered for INP reporting. The\n * default threshold is `40`, which means INP scores of less than 40 are\n * reported as 0. Note that this will not affect your 75th percentile INP value\n * unless that value is also less than 40 (well below the recommended\n * [good](https://web.dev/articles/inp#what_is_a_good_inp_score) threshold).\n *\n * If the `reportAllChanges` configuration option is set to `true`, the\n * `callback` function will be called as soon as the value is initially\n * determined as well as any time the value changes throughout the page\n * lifespan.\n *\n * _**Important:** INP should be continually monitored for changes throughout\n * the entire lifespan of a page—including if the user returns to the page after\n * it's been hidden/backgrounded. However, since browsers often [will not fire\n * additional callbacks once the user has backgrounded a\n * page](https://developer.chrome.com/blog/page-lifecycle-api/#advice-hidden),\n * `callback` is always called when the page's visibility state changes to\n * hidden. As a result, the `callback` function might be called multiple times\n * during the same page load._\n */\nconst onINP = (onReport, opts = {}) => {\n  // Return if the browser doesn't support all APIs needed to measure INP.\n  if (!('PerformanceEventTiming' in WINDOW && 'interactionId' in PerformanceEventTiming.prototype)) {\n    return;\n  }\n\n  whenActivated(() => {\n    // TODO(philipwalton): remove once the polyfill is no longer needed.\n    initInteractionCountPolyfill();\n\n    const metric = initMetric('INP');\n    // eslint-disable-next-line prefer-const\n    let report;\n\n    const handleEntries = (entries) => {\n      // Queue the `handleEntries()` callback in the next idle task.\n      // This is needed to increase the chances that all event entries that\n      // occurred between the user interaction and the next paint\n      // have been dispatched. Note: there is currently an experiment\n      // running in Chrome (EventTimingKeypressAndCompositionInteractionId)\n      // 123+ that if rolled out fully may make this no longer necessary.\n      whenIdle(() => {\n        entries.forEach(processInteractionEntry);\n\n        const inp = estimateP98LongestInteraction();\n\n        if (inp && inp.latency !== metric.value) {\n          metric.value = inp.latency;\n          metric.entries = inp.entries;\n          report();\n        }\n      });\n    };\n\n    const po = observe('event', handleEntries, {\n      // Event Timing entries have their durations rounded to the nearest 8ms,\n      // so a duration of 40ms would be any event that spans 2.5 or more frames\n      // at 60Hz. This threshold is chosen to strike a balance between usefulness\n      // and performance. Running this callback for any interaction that spans\n      // just one or two frames is likely not worth the insight that could be\n      // gained.\n      durationThreshold: opts.durationThreshold != null ? opts.durationThreshold : DEFAULT_DURATION_THRESHOLD,\n    });\n\n    report = bindReporter(onReport, metric, INPThresholds, opts.reportAllChanges);\n\n    if (po) {\n      // Also observe entries of type `first-input`. This is useful in cases\n      // where the first interaction is less than the `durationThreshold`.\n      po.observe({ type: 'first-input', buffered: true });\n\n      onHidden(() => {\n        handleEntries(po.takeRecords() );\n        report(true);\n      });\n    }\n  });\n};\n\nexport { INPThresholds, onINP };\n//# sourceMappingURL=getINP.js.map\n","import { WINDOW } from '../../types.js';\nimport { bindReporter } from './lib/bindReporter.js';\nimport { getActivationStart } from './lib/getActivationStart.js';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\nimport { runOnce } from './lib/runOnce.js';\nimport { whenActivated } from './lib/whenActivated.js';\nimport { whenIdle } from './lib/whenIdle.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** Thresholds for LCP. See https://web.dev/articles/lcp#what_is_a_good_lcp_score */\nconst LCPThresholds = [2500, 4000];\n\nconst reportedMetricIDs = {};\n\n/**\n * Calculates the [LCP](https://web.dev/articles/lcp) value for the current page and\n * calls the `callback` function once the value is ready (along with the\n * relevant `largest-contentful-paint` performance entry used to determine the\n * value). The reported value is a `DOMHighResTimeStamp`.\n *\n * If the `reportAllChanges` configuration option is set to `true`, the\n * `callback` function will be called any time a new `largest-contentful-paint`\n * performance entry is dispatched, or once the final value of the metric has\n * been determined.\n */\nconst onLCP = (onReport, opts = {}) => {\n  whenActivated(() => {\n    const visibilityWatcher = getVisibilityWatcher();\n    const metric = initMetric('LCP');\n    let report;\n\n    const handleEntries = (entries) => {\n      // If reportAllChanges is set then call this function for each entry,\n      // otherwise only consider the last one.\n      if (!opts.reportAllChanges) {\n        // eslint-disable-next-line no-param-reassign\n        entries = entries.slice(-1);\n      }\n\n      entries.forEach(entry => {\n        // Only report if the page wasn't hidden prior to LCP.\n        if (entry.startTime < visibilityWatcher.firstHiddenTime) {\n          // The startTime attribute returns the value of the renderTime if it is\n          // not 0, and the value of the loadTime otherwise. The activationStart\n          // reference is used because LCP should be relative to page activation\n          // rather than navigation start if the page was pre-rendered. But in cases\n          // where `activationStart` occurs after the LCP, this time should be\n          // clamped at 0.\n          metric.value = Math.max(entry.startTime - getActivationStart(), 0);\n          metric.entries = [entry];\n          report();\n        }\n      });\n    };\n\n    const po = observe('largest-contentful-paint', handleEntries);\n\n    if (po) {\n      report = bindReporter(onReport, metric, LCPThresholds, opts.reportAllChanges);\n\n      const stopListening = runOnce(() => {\n        if (!reportedMetricIDs[metric.id]) {\n          handleEntries(po.takeRecords() );\n          po.disconnect();\n          reportedMetricIDs[metric.id] = true;\n          report(true);\n        }\n      });\n\n      // Stop listening after input. Note: while scrolling is an input that\n      // stops LCP observation, it's unreliable since it can be programmatically\n      // generated. See: https://github.com/GoogleChrome/web-vitals/issues/75\n      ['keydown', 'click'].forEach(type => {\n        // Wrap in a setTimeout so the callback is run in a separate task\n        // to avoid extending the keyboard/click handler to reduce INP impact\n        // https://github.com/GoogleChrome/web-vitals/issues/383\n        if (WINDOW.document) {\n          addEventListener(type, () => whenIdle(stopListening ), {\n            once: true,\n            capture: true,\n          });\n        }\n      });\n\n      onHidden(stopListening);\n    }\n  });\n};\n\nexport { LCPThresholds, onLCP };\n//# sourceMappingURL=getLCP.js.map\n","import { WINDOW } from '../../types.js';\nimport { bindReporter } from './lib/bindReporter.js';\nimport { getActivationStart } from './lib/getActivationStart.js';\nimport { getNavigationEntry } from './lib/getNavigationEntry.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { whenActivated } from './lib/whenActivated.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** Thresholds for TTFB. See https://web.dev/articles/ttfb#what_is_a_good_ttfb_score */\nconst TTFBThresholds = [800, 1800];\n\n/**\n * Runs in the next task after the page is done loading and/or prerendering.\n * @param callback\n */\nconst whenReady = (callback) => {\n  if (WINDOW.document?.prerendering) {\n    whenActivated(() => whenReady(callback));\n  } else if (WINDOW.document?.readyState !== 'complete') {\n    addEventListener('load', () => whenReady(callback), true);\n  } else {\n    // Queue a task so the callback runs after `loadEventEnd`.\n    setTimeout(callback, 0);\n  }\n};\n\n/**\n * Calculates the [TTFB](https://web.dev/articles/ttfb) value for the\n * current page and calls the `callback` function once the page has loaded,\n * along with the relevant `navigation` performance entry used to determine the\n * value. The reported value is a `DOMHighResTimeStamp`.\n *\n * Note, this function waits until after the page is loaded to call `callback`\n * in order to ensure all properties of the `navigation` entry are populated.\n * This is useful if you want to report on other metrics exposed by the\n * [Navigation Timing API](https://w3c.github.io/navigation-timing/). For\n * example, the TTFB metric starts from the page's [time\n * origin](https://www.w3.org/TR/hr-time-2/#sec-time-origin), which means it\n * includes time spent on DNS lookup, connection negotiation, network latency,\n * and server processing time.\n */\nconst onTTFB = (onReport, opts = {}) => {\n  const metric = initMetric('TTFB');\n  const report = bindReporter(onReport, metric, TTFBThresholds, opts.reportAllChanges);\n\n  whenReady(() => {\n    const navigationEntry = getNavigationEntry();\n\n    if (navigationEntry) {\n      // The activationStart reference is used because TTFB should be\n      // relative to page activation rather than navigation start if the\n      // page was prerendered. But in cases where `activationStart` occurs\n      // after the first byte is received, this time should be clamped at 0.\n      metric.value = Math.max(navigationEntry.responseStart - getActivationStart(), 0);\n\n      metric.entries = [navigationEntry];\n      report(true);\n    }\n  });\n};\n\nexport { TTFBThresholds, onTTFB };\n//# sourceMappingURL=onTTFB.js.map\n","import { logger, getFunctionName } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { onCLS } from './web-vitals/getCLS.js';\nimport { onFID } from './web-vitals/getFID.js';\nimport { onINP } from './web-vitals/getINP.js';\nimport { onLCP } from './web-vitals/getLCP.js';\nimport { observe } from './web-vitals/lib/observe.js';\nimport { onTTFB } from './web-vitals/onTTFB.js';\n\nconst handlers = {};\nconst instrumented = {};\n\nlet _previousCls;\nlet _previousFid;\nlet _previousLcp;\nlet _previousTtfb;\nlet _previousInp;\n\n/**\n * Add a callback that will be triggered when a CLS metric is available.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n *\n * Pass `stopOnCallback = true` to stop listening for CLS when the cleanup callback is called.\n * This will lead to the CLS being finalized and frozen.\n */\nfunction addClsInstrumentationHandler(\n  callback,\n  stopOnCallback = false,\n) {\n  return addMetricObserver('cls', callback, instrumentCls, _previousCls, stopOnCallback);\n}\n\n/**\n * Add a callback that will be triggered when a LCP metric is available.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n *\n * Pass `stopOnCallback = true` to stop listening for LCP when the cleanup callback is called.\n * This will lead to the LCP being finalized and frozen.\n */\nfunction addLcpInstrumentationHandler(\n  callback,\n  stopOnCallback = false,\n) {\n  return addMetricObserver('lcp', callback, instrumentLcp, _previousLcp, stopOnCallback);\n}\n\n/**\n * Add a callback that will be triggered when a FID metric is available.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n */\nfunction addFidInstrumentationHandler(callback) {\n  return addMetricObserver('fid', callback, instrumentFid, _previousFid);\n}\n\n/**\n * Add a callback that will be triggered when a FID metric is available.\n */\nfunction addTtfbInstrumentationHandler(callback) {\n  return addMetricObserver('ttfb', callback, instrumentTtfb, _previousTtfb);\n}\n\n/**\n * Add a callback that will be triggered when a INP metric is available.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n */\nfunction addInpInstrumentationHandler(\n  callback,\n) {\n  return addMetricObserver('inp', callback, instrumentInp, _previousInp);\n}\n\n/**\n * Add a callback that will be triggered when a performance observer is triggered,\n * and receives the entries of the observer.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n */\nfunction addPerformanceInstrumentationHandler(\n  type,\n  callback,\n) {\n  addHandler(type, callback);\n\n  if (!instrumented[type]) {\n    instrumentPerformanceObserver(type);\n    instrumented[type] = true;\n  }\n\n  return getCleanupCallback(type, callback);\n}\n\n/** Trigger all handlers of a given type. */\nfunction triggerHandlers(type, data) {\n  const typeHandlers = handlers[type];\n\n  if (!typeHandlers?.length) {\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\nfunction instrumentCls() {\n  return onCLS(\n    metric => {\n      triggerHandlers('cls', {\n        metric,\n      });\n      _previousCls = metric;\n    },\n    // We want the callback to be called whenever the CLS value updates.\n    // By default, the callback is only called when the tab goes to the background.\n    { reportAllChanges: true },\n  );\n}\n\nfunction instrumentFid() {\n  return onFID(metric => {\n    triggerHandlers('fid', {\n      metric,\n    });\n    _previousFid = metric;\n  });\n}\n\nfunction instrumentLcp() {\n  return onLCP(\n    metric => {\n      triggerHandlers('lcp', {\n        metric,\n      });\n      _previousLcp = metric;\n    },\n    // We want the callback to be called whenever the LCP value updates.\n    // By default, the callback is only called when the tab goes to the background.\n    { reportAllChanges: true },\n  );\n}\n\nfunction instrumentTtfb() {\n  return onTTFB(metric => {\n    triggerHandlers('ttfb', {\n      metric,\n    });\n    _previousTtfb = metric;\n  });\n}\n\nfunction instrumentInp() {\n  return onINP(metric => {\n    triggerHandlers('inp', {\n      metric,\n    });\n    _previousInp = metric;\n  });\n}\n\nfunction addMetricObserver(\n  type,\n  callback,\n  instrumentFn,\n  previousValue,\n  stopOnCallback = false,\n) {\n  addHandler(type, callback);\n\n  let stopListening;\n\n  if (!instrumented[type]) {\n    stopListening = instrumentFn();\n    instrumented[type] = true;\n  }\n\n  if (previousValue) {\n    callback({ metric: previousValue });\n  }\n\n  return getCleanupCallback(type, callback, stopOnCallback ? stopListening : undefined);\n}\n\nfunction instrumentPerformanceObserver(type) {\n  const options = {};\n\n  // Special per-type options we want to use\n  if (type === 'event') {\n    options.durationThreshold = 0;\n  }\n\n  observe(\n    type,\n    entries => {\n      triggerHandlers(type, { entries });\n    },\n    options,\n  );\n}\n\nfunction addHandler(type, handler) {\n  handlers[type] = handlers[type] || [];\n  (handlers[type] ).push(handler);\n}\n\n// Get a callback which can be called to remove the instrumentation handler\nfunction getCleanupCallback(\n  type,\n  callback,\n  stopListening,\n) {\n  return () => {\n    if (stopListening) {\n      stopListening();\n    }\n\n    const typeHandlers = handlers[type];\n\n    if (!typeHandlers) {\n      return;\n    }\n\n    const index = typeHandlers.indexOf(callback);\n    if (index !== -1) {\n      typeHandlers.splice(index, 1);\n    }\n  };\n}\n\n/**\n * Check if a PerformanceEntry is a PerformanceEventTiming by checking for the `duration` property.\n */\nfunction isPerformanceEventTiming(entry) {\n  return 'duration' in entry;\n}\n\nexport { addClsInstrumentationHandler, addFidInstrumentationHandler, addInpInstrumentationHandler, addLcpInstrumentationHandler, addPerformanceInstrumentationHandler, addTtfbInstrumentationHandler, isPerformanceEventTiming };\n//# sourceMappingURL=instrument.js.map\n","import { spanToJSON, withActiveSpan, startInactiveSpan, getClient, getCurrentScope } from '@sentry/core';\nimport { WINDOW } from '../types.js';\n\n/**\n * Checks if a given value is a valid measurement value.\n */\nfunction isMeasurementValue(value) {\n  return typeof value === 'number' && isFinite(value);\n}\n\n/**\n * Helper function to start child on transactions. This function will make sure that the transaction will\n * use the start timestamp of the created child span if it is earlier than the transactions actual\n * start timestamp.\n */\nfunction startAndEndSpan(\n  parentSpan,\n  startTimeInSeconds,\n  endTime,\n  { ...ctx },\n) {\n  const parentStartTime = spanToJSON(parentSpan).start_timestamp;\n  if (parentStartTime && parentStartTime > startTimeInSeconds) {\n    // We can only do this for SentrySpans...\n    if (typeof (parentSpan ).updateStartTime === 'function') {\n      (parentSpan ).updateStartTime(startTimeInSeconds);\n    }\n  }\n\n  // The return value only exists for tests\n  return withActiveSpan(parentSpan, () => {\n    const span = startInactiveSpan({\n      startTime: startTimeInSeconds,\n      ...ctx,\n    });\n\n    if (span) {\n      span.end(endTime);\n    }\n\n    return span;\n  });\n}\n\n/**\n * Starts an inactive, standalone span used to send web vital values to Sentry.\n * DO NOT use this for arbitrary spans, as these spans require special handling\n * during ingestion to extract metrics.\n *\n * This function adds a bunch of attributes and data to the span that's shared\n * by all web vital standalone spans. However, you need to take care of adding\n * the actual web vital value as an event to the span. Also, you need to assign\n * a transaction name and some other values that are specific to the web vital.\n *\n * Ultimately, you also need to take care of ending the span to send it off.\n *\n * @param options\n *\n * @returns an inactive, standalone and NOT YET ended span\n */\nfunction startStandaloneWebVitalSpan(options) {\n  const client = getClient();\n  if (!client) {\n    return;\n  }\n\n  const { name, transaction, attributes: passedAttributes, startTime } = options;\n\n  const { release, environment, sendDefaultPii } = client.getOptions();\n  // We need to get the replay, user, and activeTransaction from the current scope\n  // so that we can associate replay id, profile id, and a user display to the span\n  const replay = client.getIntegrationByName('Replay');\n  const replayId = replay?.getReplayId();\n\n  const scope = getCurrentScope();\n\n  const user = scope.getUser();\n  const userDisplay = user !== undefined ? user.email || user.id || user.ip_address : undefined;\n\n  let profileId;\n  try {\n    // @ts-expect-error skip optional chaining to save bundle size with try catch\n    profileId = scope.getScopeData().contexts.profile.profile_id;\n  } catch {\n    // do nothing\n  }\n\n  const attributes = {\n    release,\n    environment,\n\n    user: userDisplay || undefined,\n    profile_id: profileId || undefined,\n    replay_id: replayId || undefined,\n\n    transaction,\n\n    // Web vital score calculation relies on the user agent to account for different\n    // browsers setting different thresholds for what is considered a good/meh/bad value.\n    // For example: Chrome vs. Chrome Mobile\n    'user_agent.original': WINDOW.navigator?.userAgent,\n\n    // This tells Sentry to infer the IP address from the request\n    'client.address': sendDefaultPii ? '{{auto}}' : undefined,\n\n    ...passedAttributes,\n  };\n\n  return startInactiveSpan({\n    name,\n    attributes,\n    startTime,\n    experimental: {\n      standalone: true,\n    },\n  });\n}\n\n/** Get the browser performance API. */\nfunction getBrowserPerformanceAPI() {\n  // @ts-expect-error we want to make sure all of these are available, even if TS is sure they are\n  return WINDOW.addEventListener && WINDOW.performance;\n}\n\n/**\n * Converts from milliseconds to seconds\n * @param time time in ms\n */\nfunction msToSec(time) {\n  return time / 1000;\n}\n\n/**\n * Converts ALPN protocol ids to name and version.\n *\n * (https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids)\n * @param nextHopProtocol PerformanceResourceTiming.nextHopProtocol\n */\nfunction extractNetworkProtocol(nextHopProtocol) {\n  let name = 'unknown';\n  let version = 'unknown';\n  let _name = '';\n  for (const char of nextHopProtocol) {\n    // http/1.1 etc.\n    if (char === '/') {\n      [name, version] = nextHopProtocol.split('/') ;\n      break;\n    }\n    // h2, h3 etc.\n    if (!isNaN(Number(char))) {\n      name = _name === 'h' ? 'http' : _name;\n      version = nextHopProtocol.split(_name)[1] ;\n      break;\n    }\n    _name += char;\n  }\n  if (_name === nextHopProtocol) {\n    // webrtc, ftp, etc.\n    name = _name;\n  }\n  return { name, version };\n}\n\nexport { extractNetworkProtocol, getBrowserPerformanceAPI, isMeasurementValue, msToSec, startAndEndSpan, startStandaloneWebVitalSpan };\n//# sourceMappingURL=utils.js.map\n","import { getClient, getActiveSpan, getRootSpan, spanToJSON, logger, browserPerformanceTimeOrigin, getCurrentScope, htmlTreeAsString, dropUndefinedKeys, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME, SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT, SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { addClsInstrumentationHandler } from './instrument.js';\nimport { msToSec, startStandaloneWebVitalSpan } from './utils.js';\nimport { onHidden } from './web-vitals/lib/onHidden.js';\n\n/**\n * Starts tracking the Cumulative Layout Shift on the current page and collects the value once\n *\n * - the page visibility is hidden\n * - a navigation span is started (to stop CLS measurement for SPA soft navigations)\n *\n * Once either of these events triggers, the CLS value is sent as a standalone span and we stop\n * measuring CLS.\n */\nfunction trackClsAsStandaloneSpan() {\n  let standaloneCLsValue = 0;\n  let standaloneClsEntry;\n  let pageloadSpanId;\n\n  if (!supportsLayoutShift()) {\n    return;\n  }\n\n  let sentSpan = false;\n  function _collectClsOnce() {\n    if (sentSpan) {\n      return;\n    }\n    sentSpan = true;\n    if (pageloadSpanId) {\n      sendStandaloneClsSpan(standaloneCLsValue, standaloneClsEntry, pageloadSpanId);\n    }\n    cleanupClsHandler();\n  }\n\n  const cleanupClsHandler = addClsInstrumentationHandler(({ metric }) => {\n    const entry = metric.entries[metric.entries.length - 1] ;\n    if (!entry) {\n      return;\n    }\n    standaloneCLsValue = metric.value;\n    standaloneClsEntry = entry;\n  }, true);\n\n  // use pagehide event from web-vitals\n  onHidden(() => {\n    _collectClsOnce();\n  });\n\n  // Since the call chain of this function is synchronous and evaluates before the SDK client is created,\n  // we need to wait with subscribing to a client hook until the client is created. Therefore, we defer\n  // to the next tick after the SDK setup.\n  setTimeout(() => {\n    const client = getClient();\n\n    if (!client) {\n      return;\n    }\n\n    const unsubscribeStartNavigation = client.on('startNavigationSpan', () => {\n      _collectClsOnce();\n      unsubscribeStartNavigation?.();\n    });\n\n    const activeSpan = getActiveSpan();\n    if (activeSpan) {\n      const rootSpan = getRootSpan(activeSpan);\n      const spanJSON = spanToJSON(rootSpan);\n      if (spanJSON.op === 'pageload') {\n        pageloadSpanId = rootSpan.spanContext().spanId;\n      }\n    }\n  }, 0);\n}\n\nfunction sendStandaloneClsSpan(clsValue, entry, pageloadSpanId) {\n  DEBUG_BUILD && logger.log(`Sending CLS span (${clsValue})`);\n\n  const startTime = msToSec((browserPerformanceTimeOrigin() || 0) + (entry?.startTime || 0));\n  const routeName = getCurrentScope().getScopeData().transactionName;\n\n  const name = entry ? htmlTreeAsString(entry.sources[0]?.node) : 'Layout shift';\n\n  const attributes = dropUndefinedKeys({\n    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.browser.cls',\n    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'ui.webvital.cls',\n    [SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME]: entry?.duration || 0,\n    // attach the pageload span id to the CLS span so that we can link them in the UI\n    'sentry.pageload.span_id': pageloadSpanId,\n  });\n\n  const span = startStandaloneWebVitalSpan({\n    name,\n    transaction: routeName,\n    attributes,\n    startTime,\n  });\n\n  if (span) {\n    span.addEvent('cls', {\n      [SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT]: '',\n      [SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE]: clsValue,\n    });\n\n    // LayoutShift performance entries always have a duration of 0, so we don't need to add `entry.duration` here\n    // see: https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntry/duration\n    span.end(startTime);\n  }\n}\n\nfunction supportsLayoutShift() {\n  try {\n    return PerformanceObserver.supportedEntryTypes.includes('layout-shift');\n  } catch {\n    return false;\n  }\n}\n\nexport { trackClsAsStandaloneSpan };\n//# sourceMappingURL=cls.js.map\n","import { browserPerformanceTimeOrigin, getActiveSpan, spanToJSON, setMeasurement, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, parseUrl, htmlTreeAsString, getComponentName } from '@sentry/core';\nimport { WINDOW } from '../types.js';\nimport { trackClsAsStandaloneSpan } from './cls.js';\nimport { addPerformanceInstrumentationHandler, addClsInstrumentationHandler, addLcpInstrumentationHandler, addFidInstrumentationHandler, addTtfbInstrumentationHandler } from './instrument.js';\nimport { getBrowserPerformanceAPI, msToSec, startAndEndSpan, extractNetworkProtocol, isMeasurementValue } from './utils.js';\nimport { getActivationStart } from './web-vitals/lib/getActivationStart.js';\nimport { getNavigationEntry } from './web-vitals/lib/getNavigationEntry.js';\nimport { getVisibilityWatcher } from './web-vitals/lib/getVisibilityWatcher.js';\n\nconst MAX_INT_AS_BYTES = 2147483647;\n\nlet _performanceCursor = 0;\n\nlet _measurements = {};\nlet _lcpEntry;\nlet _clsEntry;\n\n/**\n * Start tracking web vitals.\n * The callback returned by this function can be used to stop tracking & ensure all measurements are final & captured.\n *\n * @returns A function that forces web vitals collection\n */\nfunction startTrackingWebVitals({ recordClsStandaloneSpans }) {\n  const performance = getBrowserPerformanceAPI();\n  if (performance && browserPerformanceTimeOrigin()) {\n    // @ts-expect-error we want to make sure all of these are available, even if TS is sure they are\n    if (performance.mark) {\n      WINDOW.performance.mark('sentry-tracing-init');\n    }\n    const fidCleanupCallback = _trackFID();\n    const lcpCleanupCallback = _trackLCP();\n    const ttfbCleanupCallback = _trackTtfb();\n    const clsCleanupCallback = recordClsStandaloneSpans ? trackClsAsStandaloneSpan() : _trackCLS();\n\n    return () => {\n      fidCleanupCallback();\n      lcpCleanupCallback();\n      ttfbCleanupCallback();\n      clsCleanupCallback?.();\n    };\n  }\n\n  return () => undefined;\n}\n\n/**\n * Start tracking long tasks.\n */\nfunction startTrackingLongTasks() {\n  addPerformanceInstrumentationHandler('longtask', ({ entries }) => {\n    const parent = getActiveSpan();\n    if (!parent) {\n      return;\n    }\n\n    const { op: parentOp, start_timestamp: parentStartTimestamp } = spanToJSON(parent);\n\n    for (const entry of entries) {\n      const startTime = msToSec((browserPerformanceTimeOrigin() ) + entry.startTime);\n      const duration = msToSec(entry.duration);\n\n      if (parentOp === 'navigation' && parentStartTimestamp && startTime < parentStartTimestamp) {\n        // Skip adding a span if the long task started before the navigation started.\n        // `startAndEndSpan` will otherwise adjust the parent's start time to the span's start\n        // time, potentially skewing the duration of the actual navigation as reported via our\n        // routing instrumentations\n        continue;\n      }\n\n      startAndEndSpan(parent, startTime, startTime + duration, {\n        name: 'Main UI thread blocked',\n        op: 'ui.long-task',\n        attributes: {\n          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n        },\n      });\n    }\n  });\n}\n\n/**\n * Start tracking long animation frames.\n */\nfunction startTrackingLongAnimationFrames() {\n  // NOTE: the current web-vitals version (3.5.2) does not support long-animation-frame, so\n  // we directly observe `long-animation-frame` events instead of through the web-vitals\n  // `observe` helper function.\n  const observer = new PerformanceObserver(list => {\n    const parent = getActiveSpan();\n    if (!parent) {\n      return;\n    }\n    for (const entry of list.getEntries() ) {\n      if (!entry.scripts[0]) {\n        continue;\n      }\n\n      const startTime = msToSec((browserPerformanceTimeOrigin() ) + entry.startTime);\n\n      const { start_timestamp: parentStartTimestamp, op: parentOp } = spanToJSON(parent);\n\n      if (parentOp === 'navigation' && parentStartTimestamp && startTime < parentStartTimestamp) {\n        // Skip adding the span if the long animation frame started before the navigation started.\n        // `startAndEndSpan` will otherwise adjust the parent's start time to the span's start\n        // time, potentially skewing the duration of the actual navigation as reported via our\n        // routing instrumentations\n        continue;\n      }\n      const duration = msToSec(entry.duration);\n\n      const attributes = {\n        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n      };\n\n      const initialScript = entry.scripts[0];\n      const { invoker, invokerType, sourceURL, sourceFunctionName, sourceCharPosition } = initialScript;\n      attributes['browser.script.invoker'] = invoker;\n      attributes['browser.script.invoker_type'] = invokerType;\n      if (sourceURL) {\n        attributes['code.filepath'] = sourceURL;\n      }\n      if (sourceFunctionName) {\n        attributes['code.function'] = sourceFunctionName;\n      }\n      if (sourceCharPosition !== -1) {\n        attributes['browser.script.source_char_position'] = sourceCharPosition;\n      }\n\n      startAndEndSpan(parent, startTime, startTime + duration, {\n        name: 'Main UI thread blocked',\n        op: 'ui.long-animation-frame',\n        attributes,\n      });\n    }\n  });\n\n  observer.observe({ type: 'long-animation-frame', buffered: true });\n}\n\n/**\n * Start tracking interaction events.\n */\nfunction startTrackingInteractions() {\n  addPerformanceInstrumentationHandler('event', ({ entries }) => {\n    const parent = getActiveSpan();\n    if (!parent) {\n      return;\n    }\n    for (const entry of entries) {\n      if (entry.name === 'click') {\n        const startTime = msToSec((browserPerformanceTimeOrigin() ) + entry.startTime);\n        const duration = msToSec(entry.duration);\n\n        const spanOptions = {\n          name: htmlTreeAsString(entry.target),\n          op: `ui.interaction.${entry.name}`,\n          startTime: startTime,\n          attributes: {\n            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n          },\n        };\n\n        const componentName = getComponentName(entry.target);\n        if (componentName) {\n          spanOptions.attributes['ui.component_name'] = componentName;\n        }\n\n        startAndEndSpan(parent, startTime, startTime + duration, spanOptions);\n      }\n    }\n  });\n}\n\n/**\n * Starts tracking the Cumulative Layout Shift on the current page and collects the value and last entry\n * to the `_measurements` object which ultimately is applied to the pageload span's measurements.\n */\nfunction _trackCLS() {\n  return addClsInstrumentationHandler(({ metric }) => {\n    const entry = metric.entries[metric.entries.length - 1] ;\n    if (!entry) {\n      return;\n    }\n    _measurements['cls'] = { value: metric.value, unit: '' };\n    _clsEntry = entry;\n  }, true);\n}\n\n/** Starts tracking the Largest Contentful Paint on the current page. */\nfunction _trackLCP() {\n  return addLcpInstrumentationHandler(({ metric }) => {\n    const entry = metric.entries[metric.entries.length - 1];\n    if (!entry) {\n      return;\n    }\n\n    _measurements['lcp'] = { value: metric.value, unit: 'millisecond' };\n    _lcpEntry = entry ;\n  }, true);\n}\n\n/** Starts tracking the First Input Delay on the current page. */\nfunction _trackFID() {\n  return addFidInstrumentationHandler(({ metric }) => {\n    const entry = metric.entries[metric.entries.length - 1];\n    if (!entry) {\n      return;\n    }\n\n    const timeOrigin = msToSec(browserPerformanceTimeOrigin() );\n    const startTime = msToSec(entry.startTime);\n    _measurements['fid'] = { value: metric.value, unit: 'millisecond' };\n    _measurements['mark.fid'] = { value: timeOrigin + startTime, unit: 'second' };\n  });\n}\n\nfunction _trackTtfb() {\n  return addTtfbInstrumentationHandler(({ metric }) => {\n    const entry = metric.entries[metric.entries.length - 1];\n    if (!entry) {\n      return;\n    }\n\n    _measurements['ttfb'] = { value: metric.value, unit: 'millisecond' };\n  });\n}\n\n/** Add performance related spans to a transaction */\nfunction addPerformanceEntries(span, options) {\n  const performance = getBrowserPerformanceAPI();\n  const origin = browserPerformanceTimeOrigin();\n  if (!performance?.getEntries || !origin) {\n    // Gatekeeper if performance API not available\n    return;\n  }\n\n  const timeOrigin = msToSec(origin);\n\n  const performanceEntries = performance.getEntries();\n\n  const { op, start_timestamp: transactionStartTime } = spanToJSON(span);\n\n  performanceEntries.slice(_performanceCursor).forEach(entry => {\n    const startTime = msToSec(entry.startTime);\n    const duration = msToSec(\n      // Inexplicably, Chrome sometimes emits a negative duration. We need to work around this.\n      // There is a SO post attempting to explain this, but it leaves one with open questions: https://stackoverflow.com/questions/23191918/peformance-getentries-and-negative-duration-display\n      // The way we clamp the value is probably not accurate, since we have observed this happen for things that may take a while to load, like for example the replay worker.\n      // TODO: Investigate why this happens and how to properly mitigate. For now, this is a workaround to prevent transactions being dropped due to negative duration spans.\n      Math.max(0, entry.duration),\n    );\n\n    if (op === 'navigation' && transactionStartTime && timeOrigin + startTime < transactionStartTime) {\n      return;\n    }\n\n    switch (entry.entryType) {\n      case 'navigation': {\n        _addNavigationSpans(span, entry , timeOrigin);\n        break;\n      }\n      case 'mark':\n      case 'paint':\n      case 'measure': {\n        _addMeasureSpans(span, entry, startTime, duration, timeOrigin);\n\n        // capture web vitals\n        const firstHidden = getVisibilityWatcher();\n        // Only report if the page wasn't hidden prior to the web vital.\n        const shouldRecord = entry.startTime < firstHidden.firstHiddenTime;\n\n        if (entry.name === 'first-paint' && shouldRecord) {\n          _measurements['fp'] = { value: entry.startTime, unit: 'millisecond' };\n        }\n        if (entry.name === 'first-contentful-paint' && shouldRecord) {\n          _measurements['fcp'] = { value: entry.startTime, unit: 'millisecond' };\n        }\n        break;\n      }\n      case 'resource': {\n        _addResourceSpans(span, entry , entry.name, startTime, duration, timeOrigin);\n        break;\n      }\n      // Ignore other entry types.\n    }\n  });\n\n  _performanceCursor = Math.max(performanceEntries.length - 1, 0);\n\n  _trackNavigator(span);\n\n  // Measurements are only available for pageload transactions\n  if (op === 'pageload') {\n    _addTtfbRequestTimeToMeasurements(_measurements);\n\n    const fidMark = _measurements['mark.fid'];\n    if (fidMark && _measurements['fid']) {\n      // create span for FID\n      startAndEndSpan(span, fidMark.value, fidMark.value + msToSec(_measurements['fid'].value), {\n        name: 'first input delay',\n        op: 'ui.action',\n        attributes: {\n          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n        },\n      });\n\n      // Delete mark.fid as we don't want it to be part of final payload\n      delete _measurements['mark.fid'];\n    }\n\n    // If FCP is not recorded we should not record the cls value\n    // according to the new definition of CLS.\n    // TODO: Check if the first condition is still necessary: `onCLS` already only fires once `onFCP` was called.\n    if (!('fcp' in _measurements) || !options.recordClsOnPageloadSpan) {\n      delete _measurements.cls;\n    }\n\n    Object.entries(_measurements).forEach(([measurementName, measurement]) => {\n      setMeasurement(measurementName, measurement.value, measurement.unit);\n    });\n\n    // Set timeOrigin which denotes the timestamp which to base the LCP/FCP/FP/TTFB measurements on\n    span.setAttribute('performance.timeOrigin', timeOrigin);\n\n    // In prerendering scenarios, where a page might be prefetched and pre-rendered before the user clicks the link,\n    // the navigation starts earlier than when the user clicks it. Web Vitals should always be based on the\n    // user-perceived time, so they are not reported from the actual start of the navigation, but rather from the\n    // time where the user actively started the navigation, for example by clicking a link.\n    // This is user action is called \"activation\" and the time between navigation and activation is stored in\n    // the `activationStart` attribute of the \"navigation\" PerformanceEntry.\n    span.setAttribute('performance.activationStart', getActivationStart());\n\n    _setWebVitalAttributes(span);\n  }\n\n  _lcpEntry = undefined;\n  _clsEntry = undefined;\n  _measurements = {};\n}\n\n/**\n * Create measure related spans.\n * Exported only for tests.\n */\nfunction _addMeasureSpans(\n  span,\n  entry,\n  startTime,\n  duration,\n  timeOrigin,\n) {\n  const navEntry = getNavigationEntry(false);\n  const requestTime = msToSec(navEntry ? navEntry.requestStart : 0);\n  // Because performance.measure accepts arbitrary timestamps it can produce\n  // spans that happen before the browser even makes a request for the page.\n  //\n  // An example of this is the automatically generated Next.js-before-hydration\n  // spans created by the Next.js framework.\n  //\n  // To prevent this we will pin the start timestamp to the request start time\n  // This does make duration inaccurate, so if this does happen, we will add\n  // an attribute to the span\n  const measureStartTimestamp = timeOrigin + Math.max(startTime, requestTime);\n  const startTimeStamp = timeOrigin + startTime;\n  const measureEndTimestamp = startTimeStamp + duration;\n\n  const attributes = {\n    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.resource.browser.metrics',\n  };\n\n  if (measureStartTimestamp !== startTimeStamp) {\n    attributes['sentry.browser.measure_happened_before_request'] = true;\n    attributes['sentry.browser.measure_start_time'] = measureStartTimestamp;\n  }\n\n  startAndEndSpan(span, measureStartTimestamp, measureEndTimestamp, {\n    name: entry.name ,\n    op: entry.entryType ,\n    attributes,\n  });\n\n  return measureStartTimestamp;\n}\n\n/** Instrument navigation entries */\nfunction _addNavigationSpans(span, entry, timeOrigin) {\n  (['unloadEvent', 'redirect', 'domContentLoadedEvent', 'loadEvent', 'connect'] ).forEach(event => {\n    _addPerformanceNavigationTiming(span, entry, event, timeOrigin);\n  });\n  _addPerformanceNavigationTiming(span, entry, 'secureConnection', timeOrigin, 'TLS/SSL');\n  _addPerformanceNavigationTiming(span, entry, 'fetch', timeOrigin, 'cache');\n  _addPerformanceNavigationTiming(span, entry, 'domainLookup', timeOrigin, 'DNS');\n\n  _addRequest(span, entry, timeOrigin);\n}\n\n/** Create performance navigation related spans */\nfunction _addPerformanceNavigationTiming(\n  span,\n  entry,\n  event,\n  timeOrigin,\n  name = event,\n) {\n  const eventEnd = _getEndPropertyNameForNavigationTiming(event) ;\n  const end = entry[eventEnd];\n  const start = entry[`${event}Start`];\n  if (!start || !end) {\n    return;\n  }\n  startAndEndSpan(span, timeOrigin + msToSec(start), timeOrigin + msToSec(end), {\n    op: `browser.${name}`,\n    name: entry.name,\n    attributes: {\n      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n    },\n  });\n}\n\nfunction _getEndPropertyNameForNavigationTiming(event) {\n  if (event === 'secureConnection') {\n    return 'connectEnd';\n  }\n  if (event === 'fetch') {\n    return 'domainLookupStart';\n  }\n  return `${event}End`;\n}\n\n/** Create request and response related spans */\nfunction _addRequest(span, entry, timeOrigin) {\n  const requestStartTimestamp = timeOrigin + msToSec(entry.requestStart );\n  const responseEndTimestamp = timeOrigin + msToSec(entry.responseEnd );\n  const responseStartTimestamp = timeOrigin + msToSec(entry.responseStart );\n  if (entry.responseEnd) {\n    // It is possible that we are collecting these metrics when the page hasn't finished loading yet, for example when the HTML slowly streams in.\n    // In this case, ie. when the document request hasn't finished yet, `entry.responseEnd` will be 0.\n    // In order not to produce faulty spans, where the end timestamp is before the start timestamp, we will only collect\n    // these spans when the responseEnd value is available. The backend (Relay) would drop the entire span if it contained faulty spans.\n    startAndEndSpan(span, requestStartTimestamp, responseEndTimestamp, {\n      op: 'browser.request',\n      name: entry.name,\n      attributes: {\n        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n      },\n    });\n\n    startAndEndSpan(span, responseStartTimestamp, responseEndTimestamp, {\n      op: 'browser.response',\n      name: entry.name,\n      attributes: {\n        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n      },\n    });\n  }\n}\n\n/**\n * Create resource-related spans.\n * Exported only for tests.\n */\nfunction _addResourceSpans(\n  span,\n  entry,\n  resourceUrl,\n  startTime,\n  duration,\n  timeOrigin,\n) {\n  // we already instrument based on fetch and xhr, so we don't need to\n  // duplicate spans here.\n  if (entry.initiatorType === 'xmlhttprequest' || entry.initiatorType === 'fetch') {\n    return;\n  }\n\n  const parsedUrl = parseUrl(resourceUrl);\n\n  const attributes = {\n    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.resource.browser.metrics',\n  };\n  setResourceEntrySizeData(attributes, entry, 'transferSize', 'http.response_transfer_size');\n  setResourceEntrySizeData(attributes, entry, 'encodedBodySize', 'http.response_content_length');\n  setResourceEntrySizeData(attributes, entry, 'decodedBodySize', 'http.decoded_response_content_length');\n\n  // `deliveryType` is experimental and does not exist everywhere\n  const deliveryType = (entry ).deliveryType;\n  if (deliveryType != null) {\n    attributes['http.response_delivery_type'] = deliveryType;\n  }\n\n  // Types do not reflect this property yet\n  const renderBlockingStatus = (entry )\n    .renderBlockingStatus;\n  if (renderBlockingStatus) {\n    attributes['resource.render_blocking_status'] = renderBlockingStatus;\n  }\n\n  if (parsedUrl.protocol) {\n    attributes['url.scheme'] = parsedUrl.protocol.split(':').pop(); // the protocol returned by parseUrl includes a :, but OTEL spec does not, so we remove it.\n  }\n\n  if (parsedUrl.host) {\n    attributes['server.address'] = parsedUrl.host;\n  }\n\n  attributes['url.same_origin'] = resourceUrl.includes(WINDOW.location.origin);\n\n  const { name, version } = extractNetworkProtocol(entry.nextHopProtocol);\n  attributes['network.protocol.name'] = name;\n  attributes['network.protocol.version'] = version;\n\n  const startTimestamp = timeOrigin + startTime;\n  const endTimestamp = startTimestamp + duration;\n\n  startAndEndSpan(span, startTimestamp, endTimestamp, {\n    name: resourceUrl.replace(WINDOW.location.origin, ''),\n    op: entry.initiatorType ? `resource.${entry.initiatorType}` : 'resource.other',\n    attributes,\n  });\n}\n\n/**\n * Capture the information of the user agent.\n */\nfunction _trackNavigator(span) {\n  const navigator = WINDOW.navigator ;\n  if (!navigator) {\n    return;\n  }\n\n  // track network connectivity\n  const connection = navigator.connection;\n  if (connection) {\n    if (connection.effectiveType) {\n      span.setAttribute('effectiveConnectionType', connection.effectiveType);\n    }\n\n    if (connection.type) {\n      span.setAttribute('connectionType', connection.type);\n    }\n\n    if (isMeasurementValue(connection.rtt)) {\n      _measurements['connection.rtt'] = { value: connection.rtt, unit: 'millisecond' };\n    }\n  }\n\n  if (isMeasurementValue(navigator.deviceMemory)) {\n    span.setAttribute('deviceMemory', `${navigator.deviceMemory} GB`);\n  }\n\n  if (isMeasurementValue(navigator.hardwareConcurrency)) {\n    span.setAttribute('hardwareConcurrency', String(navigator.hardwareConcurrency));\n  }\n}\n\n/** Add LCP / CLS data to span to allow debugging */\nfunction _setWebVitalAttributes(span) {\n  if (_lcpEntry) {\n    // Capture Properties of the LCP element that contributes to the LCP.\n\n    if (_lcpEntry.element) {\n      span.setAttribute('lcp.element', htmlTreeAsString(_lcpEntry.element));\n    }\n\n    if (_lcpEntry.id) {\n      span.setAttribute('lcp.id', _lcpEntry.id);\n    }\n\n    if (_lcpEntry.url) {\n      // Trim URL to the first 200 characters.\n      span.setAttribute('lcp.url', _lcpEntry.url.trim().slice(0, 200));\n    }\n\n    if (_lcpEntry.loadTime != null) {\n      // loadTime is the time of LCP that's related to receiving the LCP element response..\n      span.setAttribute('lcp.loadTime', _lcpEntry.loadTime);\n    }\n\n    if (_lcpEntry.renderTime != null) {\n      // renderTime is loadTime + rendering time\n      // it's 0 if the LCP element is loaded from a 3rd party origin that doesn't send the\n      // `Timing-Allow-Origin` header.\n      span.setAttribute('lcp.renderTime', _lcpEntry.renderTime);\n    }\n\n    span.setAttribute('lcp.size', _lcpEntry.size);\n  }\n\n  // See: https://developer.mozilla.org/en-US/docs/Web/API/LayoutShift\n  if (_clsEntry?.sources) {\n    _clsEntry.sources.forEach((source, index) =>\n      span.setAttribute(`cls.source.${index + 1}`, htmlTreeAsString(source.node)),\n    );\n  }\n}\n\nfunction setResourceEntrySizeData(\n  attributes,\n  entry,\n  key,\n  dataKey,\n) {\n  const entryVal = entry[key];\n  if (entryVal != null && entryVal < MAX_INT_AS_BYTES) {\n    attributes[dataKey] = entryVal;\n  }\n}\n\n/**\n * Add ttfb request time information to measurements.\n *\n * ttfb information is added via vendored web vitals library.\n */\nfunction _addTtfbRequestTimeToMeasurements(_measurements) {\n  const navEntry = getNavigationEntry(false);\n  if (!navEntry) {\n    return;\n  }\n\n  const { responseStart, requestStart } = navEntry;\n\n  if (requestStart <= responseStart) {\n    _measurements['ttfb.requestTime'] = {\n      value: responseStart - requestStart,\n      unit: 'millisecond',\n    };\n  }\n}\n\nexport { _addMeasureSpans, _addResourceSpans, addPerformanceEntries, startTrackingInteractions, startTrackingLongAnimationFrames, startTrackingLongTasks, startTrackingWebVitals };\n//# sourceMappingURL=browserMetrics.js.map\n","import { browserPerformanceTimeOrigin, getActiveSpan, getRootSpan, spanToJSON, getCurrentScope, htmlTreeAsString, dropUndefinedKeys, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME, SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT, SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE } from '@sentry/core';\nimport { addInpInstrumentationHandler, addPerformanceInstrumentationHandler, isPerformanceEventTiming } from './instrument.js';\nimport { getBrowserPerformanceAPI, msToSec, startStandaloneWebVitalSpan } from './utils.js';\n\nconst LAST_INTERACTIONS = [];\nconst INTERACTIONS_SPAN_MAP = new Map();\n\n/**\n * Start tracking INP webvital events.\n */\nfunction startTrackingINP() {\n  const performance = getBrowserPerformanceAPI();\n  if (performance && browserPerformanceTimeOrigin()) {\n    const inpCallback = _trackINP();\n\n    return () => {\n      inpCallback();\n    };\n  }\n\n  return () => undefined;\n}\n\nconst INP_ENTRY_MAP = {\n  click: 'click',\n  pointerdown: 'click',\n  pointerup: 'click',\n  mousedown: 'click',\n  mouseup: 'click',\n  touchstart: 'click',\n  touchend: 'click',\n  mouseover: 'hover',\n  mouseout: 'hover',\n  mouseenter: 'hover',\n  mouseleave: 'hover',\n  pointerover: 'hover',\n  pointerout: 'hover',\n  pointerenter: 'hover',\n  pointerleave: 'hover',\n  dragstart: 'drag',\n  dragend: 'drag',\n  drag: 'drag',\n  dragenter: 'drag',\n  dragleave: 'drag',\n  dragover: 'drag',\n  drop: 'drag',\n  keydown: 'press',\n  keyup: 'press',\n  keypress: 'press',\n  input: 'press',\n};\n\n/** Starts tracking the Interaction to Next Paint on the current page. */\nfunction _trackINP() {\n  return addInpInstrumentationHandler(({ metric }) => {\n    if (metric.value == undefined) {\n      return;\n    }\n\n    const entry = metric.entries.find(entry => entry.duration === metric.value && INP_ENTRY_MAP[entry.name]);\n\n    if (!entry) {\n      return;\n    }\n\n    const { interactionId } = entry;\n    const interactionType = INP_ENTRY_MAP[entry.name];\n\n    /** Build the INP span, create an envelope from the span, and then send the envelope */\n    const startTime = msToSec((browserPerformanceTimeOrigin() ) + entry.startTime);\n    const duration = msToSec(metric.value);\n    const activeSpan = getActiveSpan();\n    const rootSpan = activeSpan ? getRootSpan(activeSpan) : undefined;\n\n    // We first try to lookup the span from our INTERACTIONS_SPAN_MAP,\n    // where we cache the route per interactionId\n    const cachedSpan = interactionId != null ? INTERACTIONS_SPAN_MAP.get(interactionId) : undefined;\n\n    const spanToUse = cachedSpan || rootSpan;\n\n    // Else, we try to use the active span.\n    // Finally, we fall back to look at the transactionName on the scope\n    const routeName = spanToUse ? spanToJSON(spanToUse).description : getCurrentScope().getScopeData().transactionName;\n\n    const name = htmlTreeAsString(entry.target);\n    const attributes = dropUndefinedKeys({\n      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.browser.inp',\n      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: `ui.interaction.${interactionType}`,\n      [SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME]: entry.duration,\n    });\n\n    const span = startStandaloneWebVitalSpan({\n      name,\n      transaction: routeName,\n      attributes,\n      startTime,\n    });\n\n    if (span) {\n      span.addEvent('inp', {\n        [SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT]: 'millisecond',\n        [SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE]: metric.value,\n      });\n\n      span.end(startTime + duration);\n    }\n  });\n}\n\n/**\n * Register a listener to cache route information for INP interactions.\n */\nfunction registerInpInteractionListener() {\n  const handleEntries = ({ entries }) => {\n    const activeSpan = getActiveSpan();\n    const activeRootSpan = activeSpan && getRootSpan(activeSpan);\n\n    entries.forEach(entry => {\n      if (!isPerformanceEventTiming(entry) || !activeRootSpan) {\n        return;\n      }\n\n      const interactionId = entry.interactionId;\n      if (interactionId == null) {\n        return;\n      }\n\n      // If the interaction was already recorded before, nothing more to do\n      if (INTERACTIONS_SPAN_MAP.has(interactionId)) {\n        return;\n      }\n\n      // We keep max. 10 interactions in the list, then remove the oldest one & clean up\n      if (LAST_INTERACTIONS.length > 10) {\n        const last = LAST_INTERACTIONS.shift() ;\n        INTERACTIONS_SPAN_MAP.delete(last);\n      }\n\n      // We add the interaction to the list of recorded interactions\n      // and store the span for this interaction\n      LAST_INTERACTIONS.push(interactionId);\n      INTERACTIONS_SPAN_MAP.set(interactionId, activeRootSpan);\n    });\n  };\n\n  addPerformanceInstrumentationHandler('event', handleEntries);\n  addPerformanceInstrumentationHandler('first-input', handleEntries);\n}\n\nexport { registerInpInteractionListener, startTrackingINP };\n//# sourceMappingURL=inp.js.map\n","import { addXhrInstrumentationHandler, addPerformanceInstrumentationHandler, extractNetworkProtocol, SENTRY_XHR_DATA_KEY } from '@sentry-internal/browser-utils';\nimport { addFetchEndInstrumentationHandler, addFetchInstrumentationHandler, instrumentFetchRequest, parseUrl, spanToJSON, browserPerformanceTimeOrigin, hasSpansEnabled, setHttpStatus, getActiveSpan, startInactiveSpan, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_OP, SentryNonRecordingSpan, getClient, getTraceData, getLocationHref, stringMatchesSomePattern } from '@sentry/core';\nimport { WINDOW } from '../helpers.js';\n\n/** Options for Request Instrumentation */\n\nconst responseToSpanId = new WeakMap();\nconst spanIdToEndTimestamp = new Map();\n\nconst defaultRequestInstrumentationOptions = {\n  traceFetch: true,\n  traceXHR: true,\n  enableHTTPTimings: true,\n  trackFetchStreamPerformance: false,\n};\n\n/** Registers span creators for xhr and fetch requests  */\nfunction instrumentOutgoingRequests(client, _options) {\n  const {\n    traceFetch,\n    traceXHR,\n    trackFetchStreamPerformance,\n    shouldCreateSpanForRequest,\n    enableHTTPTimings,\n    tracePropagationTargets,\n  } = {\n    traceFetch: defaultRequestInstrumentationOptions.traceFetch,\n    traceXHR: defaultRequestInstrumentationOptions.traceXHR,\n    trackFetchStreamPerformance: defaultRequestInstrumentationOptions.trackFetchStreamPerformance,\n    ..._options,\n  };\n\n  const shouldCreateSpan =\n    typeof shouldCreateSpanForRequest === 'function' ? shouldCreateSpanForRequest : (_) => true;\n\n  const shouldAttachHeadersWithTargets = (url) => shouldAttachHeaders(url, tracePropagationTargets);\n\n  const spans = {};\n\n  if (traceFetch) {\n    // Keeping track of http requests, whose body payloads resolved later than the initial resolved request\n    // e.g. streaming using server sent events (SSE)\n    client.addEventProcessor(event => {\n      if (event.type === 'transaction' && event.spans) {\n        event.spans.forEach(span => {\n          if (span.op === 'http.client') {\n            const updatedTimestamp = spanIdToEndTimestamp.get(span.span_id);\n            if (updatedTimestamp) {\n              span.timestamp = updatedTimestamp / 1000;\n              spanIdToEndTimestamp.delete(span.span_id);\n            }\n          }\n        });\n      }\n      return event;\n    });\n\n    if (trackFetchStreamPerformance) {\n      addFetchEndInstrumentationHandler(handlerData => {\n        if (handlerData.response) {\n          const span = responseToSpanId.get(handlerData.response);\n          if (span && handlerData.endTimestamp) {\n            spanIdToEndTimestamp.set(span, handlerData.endTimestamp);\n          }\n        }\n      });\n    }\n\n    addFetchInstrumentationHandler(handlerData => {\n      const createdSpan = instrumentFetchRequest(handlerData, shouldCreateSpan, shouldAttachHeadersWithTargets, spans);\n\n      if (handlerData.response && handlerData.fetchData.__span) {\n        responseToSpanId.set(handlerData.response, handlerData.fetchData.__span);\n      }\n\n      // We cannot use `window.location` in the generic fetch instrumentation,\n      // but we need it for reliable `server.address` attribute.\n      // so we extend this in here\n      if (createdSpan) {\n        const fullUrl = getFullURL(handlerData.fetchData.url);\n        const host = fullUrl ? parseUrl(fullUrl).host : undefined;\n        createdSpan.setAttributes({\n          'http.url': fullUrl,\n          'server.address': host,\n        });\n      }\n\n      if (enableHTTPTimings && createdSpan) {\n        addHTTPTimings(createdSpan);\n      }\n    });\n  }\n\n  if (traceXHR) {\n    addXhrInstrumentationHandler(handlerData => {\n      const createdSpan = xhrCallback(handlerData, shouldCreateSpan, shouldAttachHeadersWithTargets, spans);\n      if (enableHTTPTimings && createdSpan) {\n        addHTTPTimings(createdSpan);\n      }\n    });\n  }\n}\n\nfunction isPerformanceResourceTiming(entry) {\n  return (\n    entry.entryType === 'resource' &&\n    'initiatorType' in entry &&\n    typeof (entry ).nextHopProtocol === 'string' &&\n    (entry.initiatorType === 'fetch' || entry.initiatorType === 'xmlhttprequest')\n  );\n}\n\n/**\n * Creates a temporary observer to listen to the next fetch/xhr resourcing timings,\n * so that when timings hit their per-browser limit they don't need to be removed.\n *\n * @param span A span that has yet to be finished, must contain `url` on data.\n */\nfunction addHTTPTimings(span) {\n  const { url } = spanToJSON(span).data;\n\n  if (!url || typeof url !== 'string') {\n    return;\n  }\n\n  const cleanup = addPerformanceInstrumentationHandler('resource', ({ entries }) => {\n    entries.forEach(entry => {\n      if (isPerformanceResourceTiming(entry) && entry.name.endsWith(url)) {\n        const spanData = resourceTimingEntryToSpanData(entry);\n        spanData.forEach(data => span.setAttribute(...data));\n        // In the next tick, clean this handler up\n        // We have to wait here because otherwise this cleans itself up before it is fully done\n        setTimeout(cleanup);\n      }\n    });\n  });\n}\n\nfunction getAbsoluteTime(time = 0) {\n  return ((browserPerformanceTimeOrigin() || performance.timeOrigin) + time) / 1000;\n}\n\nfunction resourceTimingEntryToSpanData(resourceTiming) {\n  const { name, version } = extractNetworkProtocol(resourceTiming.nextHopProtocol);\n\n  const timingSpanData = [];\n\n  timingSpanData.push(['network.protocol.version', version], ['network.protocol.name', name]);\n\n  if (!browserPerformanceTimeOrigin()) {\n    return timingSpanData;\n  }\n  return [\n    ...timingSpanData,\n    ['http.request.redirect_start', getAbsoluteTime(resourceTiming.redirectStart)],\n    ['http.request.fetch_start', getAbsoluteTime(resourceTiming.fetchStart)],\n    ['http.request.domain_lookup_start', getAbsoluteTime(resourceTiming.domainLookupStart)],\n    ['http.request.domain_lookup_end', getAbsoluteTime(resourceTiming.domainLookupEnd)],\n    ['http.request.connect_start', getAbsoluteTime(resourceTiming.connectStart)],\n    ['http.request.secure_connection_start', getAbsoluteTime(resourceTiming.secureConnectionStart)],\n    ['http.request.connection_end', getAbsoluteTime(resourceTiming.connectEnd)],\n    ['http.request.request_start', getAbsoluteTime(resourceTiming.requestStart)],\n    ['http.request.response_start', getAbsoluteTime(resourceTiming.responseStart)],\n    ['http.request.response_end', getAbsoluteTime(resourceTiming.responseEnd)],\n  ];\n}\n\n/**\n * A function that determines whether to attach tracing headers to a request.\n * We only export this function for testing purposes.\n */\nfunction shouldAttachHeaders(\n  targetUrl,\n  tracePropagationTargets,\n) {\n  // window.location.href not being defined is an edge case in the browser but we need to handle it.\n  // Potentially dangerous situations where it may not be defined: Browser Extensions, Web Workers, patching of the location obj\n  const href = getLocationHref();\n\n  if (!href) {\n    // If there is no window.location.origin, we default to only attaching tracing headers to relative requests, i.e. ones that start with `/`\n    // BIG DISCLAIMER: Users can call URLs with a double slash (fetch(\"//example.com/api\")), this is a shorthand for \"send to the same protocol\",\n    // so we need a to exclude those requests, because they might be cross origin.\n    const isRelativeSameOriginRequest = !!targetUrl.match(/^\\/(?!\\/)/);\n    if (!tracePropagationTargets) {\n      return isRelativeSameOriginRequest;\n    } else {\n      return stringMatchesSomePattern(targetUrl, tracePropagationTargets);\n    }\n  } else {\n    let resolvedUrl;\n    let currentOrigin;\n\n    // URL parsing may fail, we default to not attaching trace headers in that case.\n    try {\n      resolvedUrl = new URL(targetUrl, href);\n      currentOrigin = new URL(href).origin;\n    } catch (e) {\n      return false;\n    }\n\n    const isSameOriginRequest = resolvedUrl.origin === currentOrigin;\n    if (!tracePropagationTargets) {\n      return isSameOriginRequest;\n    } else {\n      return (\n        stringMatchesSomePattern(resolvedUrl.toString(), tracePropagationTargets) ||\n        (isSameOriginRequest && stringMatchesSomePattern(resolvedUrl.pathname, tracePropagationTargets))\n      );\n    }\n  }\n}\n\n/**\n * Create and track xhr request spans\n *\n * @returns Span if a span was created, otherwise void.\n */\nfunction xhrCallback(\n  handlerData,\n  shouldCreateSpan,\n  shouldAttachHeaders,\n  spans,\n) {\n  const xhr = handlerData.xhr;\n  const sentryXhrData = xhr?.[SENTRY_XHR_DATA_KEY];\n\n  if (!xhr || xhr.__sentry_own_request__ || !sentryXhrData) {\n    return undefined;\n  }\n\n  const shouldCreateSpanResult = hasSpansEnabled() && shouldCreateSpan(sentryXhrData.url);\n\n  // check first if the request has finished and is tracked by an existing span which should now end\n  if (handlerData.endTimestamp && shouldCreateSpanResult) {\n    const spanId = xhr.__sentry_xhr_span_id__;\n    if (!spanId) return;\n\n    const span = spans[spanId];\n    if (span && sentryXhrData.status_code !== undefined) {\n      setHttpStatus(span, sentryXhrData.status_code);\n      span.end();\n\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete spans[spanId];\n    }\n    return undefined;\n  }\n\n  const fullUrl = getFullURL(sentryXhrData.url);\n  const host = fullUrl ? parseUrl(fullUrl).host : undefined;\n\n  const hasParent = !!getActiveSpan();\n\n  const span =\n    shouldCreateSpanResult && hasParent\n      ? startInactiveSpan({\n          name: `${sentryXhrData.method} ${sentryXhrData.url}`,\n          attributes: {\n            type: 'xhr',\n            'http.method': sentryXhrData.method,\n            'http.url': fullUrl,\n            url: sentryXhrData.url,\n            'server.address': host,\n            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.browser',\n            [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'http.client',\n          },\n        })\n      : new SentryNonRecordingSpan();\n\n  xhr.__sentry_xhr_span_id__ = span.spanContext().spanId;\n  spans[xhr.__sentry_xhr_span_id__] = span;\n\n  if (shouldAttachHeaders(sentryXhrData.url)) {\n    addTracingHeadersToXhrRequest(\n      xhr,\n      // If performance is disabled (TWP) or there's no active root span (pageload/navigation/interaction),\n      // we do not want to use the span as base for the trace headers,\n      // which means that the headers will be generated from the scope and the sampling decision is deferred\n      hasSpansEnabled() && hasParent ? span : undefined,\n    );\n  }\n\n  const client = getClient();\n  if (client) {\n    client.emit('beforeOutgoingRequestSpan', span, handlerData );\n  }\n\n  return span;\n}\n\nfunction addTracingHeadersToXhrRequest(xhr, span) {\n  const { 'sentry-trace': sentryTrace, baggage } = getTraceData({ span });\n\n  if (sentryTrace) {\n    setHeaderOnXhr(xhr, sentryTrace, baggage);\n  }\n}\n\nfunction setHeaderOnXhr(\n  xhr,\n  sentryTraceHeader,\n  sentryBaggageHeader,\n) {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    xhr.setRequestHeader('sentry-trace', sentryTraceHeader);\n    if (sentryBaggageHeader) {\n      // From MDN: \"If this method is called several times with the same header, the values are merged into one single request header.\"\n      // We can therefore simply set a baggage header without checking what was there before\n      // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/setRequestHeader\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      xhr.setRequestHeader('baggage', sentryBaggageHeader);\n    }\n  } catch (_) {\n    // Error: InvalidStateError: Failed to execute 'setRequestHeader' on 'XMLHttpRequest': The object's state must be OPENED.\n  }\n}\n\nfunction getFullURL(url) {\n  try {\n    // By adding a base URL to new URL(), this will also work for relative urls\n    // If `url` is a full URL, the base URL is ignored anyhow\n    const parsed = new URL(url, WINDOW.location.origin);\n    return parsed.href;\n  } catch {\n    return undefined;\n  }\n}\n\nexport { defaultRequestInstrumentationOptions, instrumentOutgoingRequests, shouldAttachHeaders, xhrCallback };\n//# sourceMappingURL=request.js.map\n","import { getActiveSpan, getRootSpan, spanToJSON, logger, SPAN_STATUS_ERROR } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { WINDOW } from '../helpers.js';\n\n/**\n * Add a listener that cancels and finishes a transaction when the global\n * document is hidden.\n */\nfunction registerBackgroundTabDetection() {\n  if (WINDOW.document) {\n    WINDOW.document.addEventListener('visibilitychange', () => {\n      const activeSpan = getActiveSpan();\n      if (!activeSpan) {\n        return;\n      }\n\n      const rootSpan = getRootSpan(activeSpan);\n\n      if (WINDOW.document.hidden && rootSpan) {\n        const cancelledStatus = 'cancelled';\n\n        const { op, status } = spanToJSON(rootSpan);\n\n        if (DEBUG_BUILD) {\n          logger.log(`[Tracing] Transaction: ${cancelledStatus} -> since tab moved to the background, op: ${op}`);\n        }\n\n        // We should not set status if it is already set, this prevent important statuses like\n        // error or data loss from being overwritten on transaction.\n        if (!status) {\n          rootSpan.setStatus({ code: SPAN_STATUS_ERROR, message: cancelledStatus });\n        }\n\n        rootSpan.setAttribute('sentry.cancellation_reason', 'document.hidden');\n        rootSpan.end();\n      }\n    });\n  } else {\n    DEBUG_BUILD && logger.warn('[Tracing] Could not set up background tab detection due to lack of global document');\n  }\n}\n\nexport { registerBackgroundTabDetection };\n//# sourceMappingURL=backgroundtab.js.map\n","import { startTrackingWebVitals, startTrackingINP, startTrackingLongAnimationFrames, startTrackingLongTasks, startTrackingInteractions, addHistoryInstrumentationHandler, registerInpInteractionListener, addPerformanceEntries } from '@sentry-internal/browser-utils';\nimport { TRACING_DEFAULTS, registerSpanErrorInstrumentation, GLOBAL_OBJ, getLocationHref, getClient, getIsolationScope, generateTraceId, getCurrentScope, propagationContextFromHeaders, browserPerformanceTimeOrigin, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, startIdleSpan, spanIsSampled, getDynamicSamplingContextFromSpan, spanToJSON, logger, addNonEnumerableProperty, SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { WINDOW } from '../helpers.js';\nimport { registerBackgroundTabDetection } from './backgroundtab.js';\nimport { defaultRequestInstrumentationOptions, instrumentOutgoingRequests } from './request.js';\n\n/* eslint-disable max-lines */\n\nconst BROWSER_TRACING_INTEGRATION_ID = 'BrowserTracing';\n\nconst DEFAULT_BROWSER_TRACING_OPTIONS = {\n  ...TRACING_DEFAULTS,\n  instrumentNavigation: true,\n  instrumentPageLoad: true,\n  markBackgroundSpan: true,\n  enableLongTask: true,\n  enableLongAnimationFrame: true,\n  enableInp: true,\n  _experiments: {},\n  ...defaultRequestInstrumentationOptions,\n};\n\n/**\n * The Browser Tracing integration automatically instruments browser pageload/navigation\n * actions as transactions, and captures requests, metrics and errors as spans.\n *\n * The integration can be configured with a variety of options, and can be extended to use\n * any routing library.\n *\n * We explicitly export the proper type here, as this has to be extended in some cases.\n */\nconst browserTracingIntegration = ((_options = {}) => {\n  /**\n   * This is just a small wrapper that makes `document` optional.\n   * We want to be extra-safe and always check that this exists, to ensure weird environments do not blow up.\n   */\n  const optionalWindowDocument = WINDOW.document ;\n\n  registerSpanErrorInstrumentation();\n\n  const {\n    enableInp,\n    enableLongTask,\n    enableLongAnimationFrame,\n    _experiments: { enableInteractions, enableStandaloneClsSpans },\n    beforeStartSpan,\n    idleTimeout,\n    finalTimeout,\n    childSpanTimeout,\n    markBackgroundSpan,\n    traceFetch,\n    traceXHR,\n    trackFetchStreamPerformance,\n    shouldCreateSpanForRequest,\n    enableHTTPTimings,\n    instrumentPageLoad,\n    instrumentNavigation,\n  } = {\n    ...DEFAULT_BROWSER_TRACING_OPTIONS,\n    ..._options,\n  };\n\n  const _collectWebVitals = startTrackingWebVitals({ recordClsStandaloneSpans: enableStandaloneClsSpans || false });\n\n  if (enableInp) {\n    startTrackingINP();\n  }\n\n  if (\n    enableLongAnimationFrame &&\n    GLOBAL_OBJ.PerformanceObserver &&\n    PerformanceObserver.supportedEntryTypes &&\n    PerformanceObserver.supportedEntryTypes.includes('long-animation-frame')\n  ) {\n    startTrackingLongAnimationFrames();\n  } else if (enableLongTask) {\n    startTrackingLongTasks();\n  }\n\n  if (enableInteractions) {\n    startTrackingInteractions();\n  }\n\n  const latestRoute = {\n    name: undefined,\n    source: undefined,\n  };\n\n  /** Create routing idle transaction. */\n  function _createRouteSpan(client, startSpanOptions) {\n    const isPageloadTransaction = startSpanOptions.op === 'pageload';\n\n    const finalStartSpanOptions = beforeStartSpan\n      ? beforeStartSpan(startSpanOptions)\n      : startSpanOptions;\n\n    const attributes = finalStartSpanOptions.attributes || {};\n\n    // If `finalStartSpanOptions.name` is different than `startSpanOptions.name`\n    // it is because `beforeStartSpan` set a custom name. Therefore we set the source to 'custom'.\n    if (startSpanOptions.name !== finalStartSpanOptions.name) {\n      attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] = 'custom';\n      finalStartSpanOptions.attributes = attributes;\n    }\n\n    latestRoute.name = finalStartSpanOptions.name;\n    latestRoute.source = attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];\n\n    const idleSpan = startIdleSpan(finalStartSpanOptions, {\n      idleTimeout,\n      finalTimeout,\n      childSpanTimeout,\n      // should wait for finish signal if it's a pageload transaction\n      disableAutoFinish: isPageloadTransaction,\n      beforeSpanEnd: span => {\n        _collectWebVitals();\n        addPerformanceEntries(span, { recordClsOnPageloadSpan: !enableStandaloneClsSpans });\n        setActiveIdleSpan(client, undefined);\n\n        // A trace should stay consistent over the entire timespan of one route - even after the pageload/navigation ended.\n        // Only when another navigation happens, we want to create a new trace.\n        // This way, e.g. errors that occur after the pageload span ended are still associated to the pageload trace.\n        const scope = getCurrentScope();\n        const oldPropagationContext = scope.getPropagationContext();\n\n        scope.setPropagationContext({\n          ...oldPropagationContext,\n          traceId: idleSpan.spanContext().traceId,\n          sampled: spanIsSampled(idleSpan),\n          dsc: getDynamicSamplingContextFromSpan(span),\n        });\n      },\n    });\n    setActiveIdleSpan(client, idleSpan);\n\n    function emitFinish() {\n      if (optionalWindowDocument && ['interactive', 'complete'].includes(optionalWindowDocument.readyState)) {\n        client.emit('idleSpanEnableAutoFinish', idleSpan);\n      }\n    }\n\n    if (isPageloadTransaction && optionalWindowDocument) {\n      optionalWindowDocument.addEventListener('readystatechange', () => {\n        emitFinish();\n      });\n\n      emitFinish();\n    }\n  }\n\n  return {\n    name: BROWSER_TRACING_INTEGRATION_ID,\n    afterAllSetup(client) {\n      let startingUrl = getLocationHref();\n\n      function maybeEndActiveSpan() {\n        const activeSpan = getActiveIdleSpan(client);\n\n        if (activeSpan && !spanToJSON(activeSpan).timestamp) {\n          DEBUG_BUILD && logger.log(`[Tracing] Finishing current active span with op: ${spanToJSON(activeSpan).op}`);\n          // If there's an open active span, we need to finish it before creating an new one.\n          activeSpan.end();\n        }\n      }\n\n      client.on('startNavigationSpan', startSpanOptions => {\n        if (getClient() !== client) {\n          return;\n        }\n\n        maybeEndActiveSpan();\n\n        getIsolationScope().setPropagationContext({ traceId: generateTraceId(), sampleRand: Math.random() });\n        getCurrentScope().setPropagationContext({ traceId: generateTraceId(), sampleRand: Math.random() });\n\n        _createRouteSpan(client, {\n          op: 'navigation',\n          ...startSpanOptions,\n        });\n      });\n\n      client.on('startPageLoadSpan', (startSpanOptions, traceOptions = {}) => {\n        if (getClient() !== client) {\n          return;\n        }\n        maybeEndActiveSpan();\n\n        const sentryTrace = traceOptions.sentryTrace || getMetaContent('sentry-trace');\n        const baggage = traceOptions.baggage || getMetaContent('baggage');\n\n        const propagationContext = propagationContextFromHeaders(sentryTrace, baggage);\n        getCurrentScope().setPropagationContext(propagationContext);\n\n        _createRouteSpan(client, {\n          op: 'pageload',\n          ...startSpanOptions,\n        });\n      });\n\n      if (WINDOW.location) {\n        if (instrumentPageLoad) {\n          const origin = browserPerformanceTimeOrigin();\n          startBrowserTracingPageLoadSpan(client, {\n            name: WINDOW.location.pathname,\n            // pageload should always start at timeOrigin (and needs to be in s, not ms)\n            startTime: origin ? origin / 1000 : undefined,\n            attributes: {\n              [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',\n              [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.pageload.browser',\n            },\n          });\n        }\n\n        if (instrumentNavigation) {\n          addHistoryInstrumentationHandler(({ to, from }) => {\n            /**\n             * This early return is there to account for some cases where a navigation transaction starts right after\n             * long-running pageload. We make sure that if `from` is undefined and a valid `startingURL` exists, we don't\n             * create an uneccessary navigation transaction.\n             *\n             * This was hard to duplicate, but this behavior stopped as soon as this fix was applied. This issue might also\n             * only be caused in certain development environments where the usage of a hot module reloader is causing\n             * errors.\n             */\n            if (from === undefined && startingUrl?.indexOf(to) !== -1) {\n              startingUrl = undefined;\n              return;\n            }\n\n            if (from !== to) {\n              startingUrl = undefined;\n              startBrowserTracingNavigationSpan(client, {\n                name: WINDOW.location.pathname,\n                attributes: {\n                  [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',\n                  [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.navigation.browser',\n                },\n              });\n            }\n          });\n        }\n      }\n\n      if (markBackgroundSpan) {\n        registerBackgroundTabDetection();\n      }\n\n      if (enableInteractions) {\n        registerInteractionListener(client, idleTimeout, finalTimeout, childSpanTimeout, latestRoute);\n      }\n\n      if (enableInp) {\n        registerInpInteractionListener();\n      }\n\n      instrumentOutgoingRequests(client, {\n        traceFetch,\n        traceXHR,\n        trackFetchStreamPerformance,\n        tracePropagationTargets: client.getOptions().tracePropagationTargets,\n        shouldCreateSpanForRequest,\n        enableHTTPTimings,\n      });\n    },\n  };\n}) ;\n\n/**\n * Manually start a page load span.\n * This will only do something if a browser tracing integration integration has been setup.\n *\n * If you provide a custom `traceOptions` object, it will be used to continue the trace\n * instead of the default behavior, which is to look it up on the <meta> tags.\n */\nfunction startBrowserTracingPageLoadSpan(\n  client,\n  spanOptions,\n  traceOptions,\n) {\n  client.emit('startPageLoadSpan', spanOptions, traceOptions);\n  getCurrentScope().setTransactionName(spanOptions.name);\n\n  return getActiveIdleSpan(client);\n}\n\n/**\n * Manually start a navigation span.\n * This will only do something if a browser tracing integration has been setup.\n */\nfunction startBrowserTracingNavigationSpan(client, spanOptions) {\n  client.emit('startNavigationSpan', spanOptions);\n\n  getCurrentScope().setTransactionName(spanOptions.name);\n\n  return getActiveIdleSpan(client);\n}\n\n/** Returns the value of a meta tag */\nfunction getMetaContent(metaName) {\n  /**\n   * This is just a small wrapper that makes `document` optional.\n   * We want to be extra-safe and always check that this exists, to ensure weird environments do not blow up.\n   */\n  const optionalWindowDocument = WINDOW.document ;\n\n  const metaTag = optionalWindowDocument?.querySelector(`meta[name=${metaName}]`);\n  return metaTag?.getAttribute('content') || undefined;\n}\n\n/** Start listener for interaction transactions */\nfunction registerInteractionListener(\n  client,\n  idleTimeout,\n  finalTimeout,\n  childSpanTimeout,\n  latestRoute,\n) {\n  /**\n   * This is just a small wrapper that makes `document` optional.\n   * We want to be extra-safe and always check that this exists, to ensure weird environments do not blow up.\n   */\n  const optionalWindowDocument = WINDOW.document ;\n\n  let inflightInteractionSpan;\n  const registerInteractionTransaction = () => {\n    const op = 'ui.action.click';\n\n    const activeIdleSpan = getActiveIdleSpan(client);\n    if (activeIdleSpan) {\n      const currentRootSpanOp = spanToJSON(activeIdleSpan).op;\n      if (['navigation', 'pageload'].includes(currentRootSpanOp )) {\n        DEBUG_BUILD &&\n          logger.warn(`[Tracing] Did not create ${op} span because a pageload or navigation span is in progress.`);\n        return undefined;\n      }\n    }\n\n    if (inflightInteractionSpan) {\n      inflightInteractionSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON, 'interactionInterrupted');\n      inflightInteractionSpan.end();\n      inflightInteractionSpan = undefined;\n    }\n\n    if (!latestRoute.name) {\n      DEBUG_BUILD && logger.warn(`[Tracing] Did not create ${op} transaction because _latestRouteName is missing.`);\n      return undefined;\n    }\n\n    inflightInteractionSpan = startIdleSpan(\n      {\n        name: latestRoute.name,\n        op,\n        attributes: {\n          [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: latestRoute.source || 'url',\n        },\n      },\n      {\n        idleTimeout,\n        finalTimeout,\n        childSpanTimeout,\n      },\n    );\n  };\n\n  if (optionalWindowDocument) {\n    addEventListener('click', registerInteractionTransaction, { once: false, capture: true });\n  }\n}\n\n// We store the active idle span on the client object, so we can access it from exported functions\nconst ACTIVE_IDLE_SPAN_PROPERTY = '_sentry_idleSpan';\nfunction getActiveIdleSpan(client) {\n  return (client )[ACTIVE_IDLE_SPAN_PROPERTY];\n}\n\nfunction setActiveIdleSpan(client, span) {\n  addNonEnumerableProperty(client, ACTIVE_IDLE_SPAN_PROPERTY, span);\n}\n\nexport { BROWSER_TRACING_INTEGRATION_ID, browserTracingIntegration, getMetaContent, startBrowserTracingNavigationSpan, startBrowserTracingPageLoadSpan };\n//# sourceMappingURL=browserTracingIntegration.js.map\n","import { captureException } from '@sentry/browser';\nimport { getCurrentScope, spanToJSON, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, getActiveSpan, getRootSpan } from '@sentry/core';\n\n// The following type is an intersection of the Route type from VueRouter v2, v3, and v4.\n// This is not great, but kinda necessary to make it work with all versions at the same time.\n\n/**\n * Instrument the Vue router to create navigation spans.\n */\nfunction instrumentVueRouter(\n  router,\n  options\n\n,\n  startNavigationSpanFn,\n) {\n  let isFirstPageLoad = true;\n\n  router.onError(error => captureException(error, { mechanism: { handled: false } }));\n\n  router.beforeEach((to, from, next) => {\n    // According to docs we could use `from === VueRouter.START_LOCATION` but I couldn't get it working for Vue 2\n    // https://router.vuejs.org/api/#router-start-location\n    // https://next.router.vuejs.org/api/#start-location\n    // Additionally, Nuxt does not provide the possibility to check for `from.matched.length === 0` (this is never 0).\n    // Therefore, a flag was added to track the page-load: isFirstPageLoad\n\n    // from.name:\n    // - Vue 2: null\n    // - Vue 3: undefined\n    // - Nuxt: undefined\n    // hence only '==' instead of '===', because `undefined == null` evaluates to `true`\n    const isPageLoadNavigation =\n      (from.name == null && from.matched.length === 0) || (from.name === undefined && isFirstPageLoad);\n\n    if (isFirstPageLoad) {\n      isFirstPageLoad = false;\n    }\n\n    const attributes = {\n      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.navigation.vue',\n    };\n\n    for (const key of Object.keys(to.params)) {\n      attributes[`params.${key}`] = to.params[key];\n    }\n    for (const key of Object.keys(to.query)) {\n      const value = to.query[key];\n      if (value) {\n        attributes[`query.${key}`] = value;\n      }\n    }\n\n    // Determine a name for the routing transaction and where that name came from\n    let spanName = to.path;\n    let transactionSource = 'url';\n    if (to.name && options.routeLabel !== 'path') {\n      spanName = to.name.toString();\n      transactionSource = 'custom';\n    } else if (to.matched.length > 0) {\n      const lastIndex = to.matched.length - 1;\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      spanName = to.matched[lastIndex].path;\n      transactionSource = 'route';\n    }\n\n    getCurrentScope().setTransactionName(spanName);\n\n    if (options.instrumentPageLoad && isPageLoadNavigation) {\n      const activeRootSpan = getActiveRootSpan();\n      if (activeRootSpan) {\n        const existingAttributes = spanToJSON(activeRootSpan).data;\n        if (existingAttributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] !== 'custom') {\n          activeRootSpan.updateName(spanName);\n          activeRootSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, transactionSource);\n        }\n        // Set router attributes on the existing pageload transaction\n        // This will override the origin, and add params & query attributes\n        activeRootSpan.setAttributes({\n          ...attributes,\n          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.pageload.vue',\n        });\n      }\n    }\n\n    if (options.instrumentNavigation && !isPageLoadNavigation) {\n      attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] = transactionSource;\n      attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] = 'auto.navigation.vue';\n      startNavigationSpanFn({\n        name: spanName,\n        op: 'navigation',\n        attributes,\n      });\n    }\n\n    // Vue Router 4 no longer exposes the `next` function, so we need to\n    // check if it's available before calling it.\n    // `next` needs to be called in Vue Router 3 so that the hook is resolved.\n    if (next) {\n      next();\n    }\n  });\n}\n\nfunction getActiveRootSpan() {\n  const span = getActiveSpan();\n  const rootSpan = span && getRootSpan(span);\n\n  if (!rootSpan) {\n    return undefined;\n  }\n\n  const op = spanToJSON(rootSpan).op;\n\n  // Only use this root span if it is a pageload or navigation span\n  return op === 'navigation' || op === 'pageload' ? rootSpan : undefined;\n}\n\nexport { instrumentVueRouter };\n//# sourceMappingURL=router.js.map\n","import { browserTracingIntegration as browserTracingIntegration$1, startBrowserTracingNavigationSpan } from '@sentry/browser';\nimport { instrumentVueRouter } from './router.js';\n\n// The following type is an intersection of the Route type from VueRouter v2, v3, and v4.\n// This is not great, but kinda necessary to make it work with all versions at the same time.\n\n/**\n * A custom browser tracing integrations for Vue.\n */\nfunction browserTracingIntegration(options = {}) {\n  // If router is not passed, we just use the normal implementation\n  if (!options.router) {\n    return browserTracingIntegration$1(options);\n  }\n\n  const integration = browserTracingIntegration$1({\n    ...options,\n    instrumentNavigation: false,\n  });\n\n  const { router, instrumentNavigation = true, instrumentPageLoad = true, routeLabel = 'name' } = options;\n\n  return {\n    ...integration,\n    afterAllSetup(client) {\n      integration.afterAllSetup(client);\n\n      const startNavigationSpan = (options) => {\n        startBrowserTracingNavigationSpan(client, options);\n      };\n\n      instrumentVueRouter(router, { routeLabel, instrumentNavigation, instrumentPageLoad }, startNavigationSpan);\n    },\n  };\n}\n\nexport { browserTracingIntegration };\n//# sourceMappingURL=browserTracingIntegration.js.map\n","export type FlipperFeatures = {\n    [key: string]: boolean\n};\n\nexport type FlipperValues = {\n    [key: string]: \"on\" | \"off\"\n};\n\nconst flipper: FlipperFeatures = {};\nexport const flipperValues: FlipperValues = {};\n\nexport function initFlipper(features?: FlipperFeatures) {\n    features ||= window.appSettings?.features || {};\n    if (window.appSettings?.env !== \"production\") {\n        const params = new URLSearchParams(window.location.search);\n        for (const key of params.keys()) {\n            if (key.indexOf(\"feature_\") === 0) {\n                const flag = key.slice(\"feature_\".length);\n                const value = params.get(key) !== \"false\" && params.get(key) !== \"0\";\n                features[flag] = value;\n            }\n        }\n    }\n\n    Object.assign(flipper, features);\n    Object.assign(flipperValues, Object.keys(features).map((name) => `${name}_${features[name] ? \"on\" : \"off\"}`));\n}\n\ninitFlipper();\nexport default flipper;\n","import {browserTracingIntegration, thirdPartyErrorFilterIntegration} from \"@sentry/vue\";\nimport flipper from \"@songfinch/shared/plugins/flipper/index\";\n\nexport const sentryBaseConfig = {\n    dsn: window.appSettings.sentry_dns,\n    //release: window.appSettings.release_version, //???\n    normalizeDepth: 10,\n    debug: flipper.sentry_debug,\n    // Set tracesSampleRate to 1.0 to capture 100%\n    // of transactions for performance monitoring.\n    // We recommend adjusting this value in production\n    integrations: [\n        browserTracingIntegration(),\n        thirdPartyErrorFilterIntegration({\n            filterKeys: [\"songfinch-applications\"],\n            behaviour: \"apply-tag-if-contains-third-party-frames\",\n        }),\n    ],\n    tracesSampleRate: window.appSettings.env === \"production\" ? 0.1 : 1.0, // ???\n    tracePropagationTargets: [\"localhost\", /^https:\\/\\/.*\\.songfinch\\.com/, /^https:\\/\\/songfinch\\.com/],\n    ignoreErrors: [\n        /^AbortError:/,\n        /^Illegal invocation/, //Some TikTok pixel error\n        /^Ignore:/,\n        /^Blocked a frame with origin/,\n        /^ResizeObserver loop/,\n        /^Request aborted/,\n        /^Unable to preload CSS/,\n        /^Java exception was raised during method invocation/,\n        /^Failed to load https\\:\\/\\/www\\.googletagmanager\\.com\\/gtag\\/js/,\n        /AutoFillPopupClose/, // caused by Chrome's autofill\n        /Network Error/,\n        /^Cannot read property 'setIsViewable|fireEvent|setScreenSize|setMaxSize|setDefaultPosition|setCurrentPosition|fireChangeEvent|audioVolumeChange|fireReadyEvent'/,\n        /^Can't find variable: gmo/,\n        /^Non-Error promise rejection captured/,\n        /^The request is not allowed by the user agent/, // Caused by users no allowing permissions in browser\n        /^Can't find variable: logMutedMessage/, // only in microsoft edge on mobile (pretty sure caused by the browser)\n        /sentry-browser\\.min\\.js/ // excluding error everytime when zendesk can't load sentry-browser.min.js cuz of cache\n    ],\n    denyUrls: [\n        /^https:\\/\\/add-a-card\\.americangreetings\\.com\\/js\\/sdk\\.min\\.js$/, // ignores AG SDK errors\n        /^https?:\\/\\/(.+\\.)?userway\\.org/,\n        /^chrome-extension:\\/\\//\n    ]\n};"],"names":["errorsInstrumented","registerSpanErrorInstrumentation","addGlobalErrorInstrumentationHandler","errorCallback","addGlobalUnhandledRejectionInstrumentationHandler","activeSpan","getActiveSpan","rootSpan","getRootSpan","message","DEBUG_BUILD","logger","SPAN_STATUS_ERROR","TRACING_DEFAULTS","FINISH_REASON_HEARTBEAT_FAILED","FINISH_REASON_IDLE_TIMEOUT","FINISH_REASON_FINAL_TIMEOUT","FINISH_REASON_EXTERNAL_FINISH","startIdleSpan","startSpanOptions","options","activities","_finished","_idleTimeoutID","_finishReason","_autoFinishAllowed","_cleanupHooks","idleTimeout","finalTimeout","childSpanTimeout","beforeSpanEnd","client","getClient","hasSpansEnabled","span","SentryNonRecordingSpan","dsc","getDynamicSamplingContextFromSpan","freezeDscOnSpan","scope","getCurrentScope","previousActiveSpan","_startIdleSpan","target","thisArg","args","definedEndTimestamp","rest","timestamp","timestampInSeconds","spanEndTimestamp","spanTimeInputToSeconds","spans","getSpanDescendants","child","onIdleSpanEnded","childEndTimestamps","spanToJSON","latestSpanEndTimestamp","spanStartTimestamp","endTimestamp","_cancelIdleTimeout","_restartIdleTimeout","_restartChildSpanTimeout","_pushActivity","spanId","_popActivity","cleanup","_setSpanForScope","spanJSON","startTimestamp","SEMANTIC_ATTRIBUTE_SENTRY_IDLE_SPAN_FINISH_REASON","childSpans","discardedSpans","childSpan","childSpanJSON","childEndTimestamp","childStartTimestamp","spanStartedBeforeIdleSpanEnd","timeoutWithMarginOfError","spanEndedBeforeFinalTimeout","stringifiedSpan","removeChildSpanFromSpan","startedSpan","endedSpan","spanToAllowAutoFinish","startInactiveSpan","getTraceData","isEnabled","carrier","getMainCarrier","acs","getAsyncContextStrategy","sentryTrace","spanToTraceHeader","scopeToTraceHeader","getDynamicSamplingContextFromScope","baggage","dynamicSamplingContextToSentryBaggageHeader","TRACEPARENT_REGEXP","traceId","sampled","propagationSpanId","generateSentryTraceHeader","filenameMetadataMap","parsedStacks","ensureMetadataStacksAreParsed","parser","GLOBAL_OBJ","stack","metadata","frames","frame","getMetadataForUrl","filename","addMetadataToStackFrames","event","exception","stripMetadataFromStackFrames","thirdPartyErrorFilterIntegration","defineIntegration","envelope","forEachEnvelopeItem","item","type","stackParser","frameKeys","getBundleKeysForAllFramesWithFilenames","arrayMethod","keys","key","getFramesFromEvent","BUNDLER_PLUGIN_APP_KEY_PREFIX","instrumentFetchRequest","handlerData","shouldCreateSpan","shouldAttachHeaders","spanOrigin","shouldCreateSpanResult","endSpan","method","url","fullUrl","getFullURL","host","parseUrl","hasParent","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","SEMANTIC_ATTRIBUTE_SENTRY_OP","request","headers","_addTracingHeadersToFetchRequest","fetchHint","fetchOptionsObj","traceHeaders","isRequest","isHeaders","newHeaders","prevBaggageHeader","prevHeaderStrippedFromSentryBaggage","stripBaggageHeaderOfSentryBaggageValues","header","headerName","headerValue","existingBaggageHeader","newBaggageHeaders","headerItem","setHttpStatus","contentLength","_a","contentLengthNum","baggageHeader","baggageEntry","SENTRY_BAGGAGE_KEY_PREFIX","isInstanceOf","getRating","value","thresholds","bindReporter","callback","metric","reportAllChanges","prevValue","delta","forceReport","generateUniqueID","getNavigationEntry","checkResponseStart","navigationEntry","_b","WINDOW","getActivationStart","navEntry","initMetric","name","navigationType","observe","opts","po","list","onHidden","cb","onHiddenOrPageHide","runOnce","called","firstHiddenTime","initHiddenTime","onVisibilityUpdate","removeChangeListeners","addChangeListeners","getVisibilityWatcher","whenActivated","FCPThresholds","onFCP","onReport","visibilityWatcher","report","entries","entry","CLSThresholds","onCLS","sessionValue","sessionEntries","handleEntries","firstSessionEntry","lastSessionEntry","FIDThresholds","onFID","handleEntry","interactionCountEstimate","minKnownInteractionId","maxKnownInteractionId","updateEstimate","e","getInteractionCount","initInteractionCountPolyfill","longestInteractionList","longestInteractionMap","DEFAULT_DURATION_THRESHOLD","prevInteractionCount","getInteractionCountForNavigation","estimateP98LongestInteraction","candidateInteractionIndex","MAX_INTERACTIONS_TO_CONSIDER","entryPreProcessingCallbacks","processInteractionEntry","minLongestInteraction","existingInteraction","interaction","b","i","whenIdle","rIC","handle","INPThresholds","onINP","inp","LCPThresholds","reportedMetricIDs","onLCP","stopListening","TTFBThresholds","whenReady","onTTFB","handlers","instrumented","_previousCls","_previousFid","_previousLcp","_previousTtfb","_previousInp","addClsInstrumentationHandler","stopOnCallback","addMetricObserver","instrumentCls","addLcpInstrumentationHandler","instrumentLcp","addFidInstrumentationHandler","instrumentFid","addTtfbInstrumentationHandler","instrumentTtfb","addInpInstrumentationHandler","instrumentInp","addPerformanceInstrumentationHandler","addHandler","instrumentPerformanceObserver","getCleanupCallback","triggerHandlers","data","typeHandlers","handler","getFunctionName","instrumentFn","previousValue","index","isPerformanceEventTiming","isMeasurementValue","startAndEndSpan","parentSpan","startTimeInSeconds","endTime","ctx","parentStartTime","withActiveSpan","startStandaloneWebVitalSpan","transaction","passedAttributes","startTime","release","environment","sendDefaultPii","replay","replayId","user","userDisplay","profileId","attributes","getBrowserPerformanceAPI","msToSec","time","extractNetworkProtocol","nextHopProtocol","version","_name","char","trackClsAsStandaloneSpan","standaloneCLsValue","standaloneClsEntry","pageloadSpanId","supportsLayoutShift","sentSpan","_collectClsOnce","sendStandaloneClsSpan","cleanupClsHandler","unsubscribeStartNavigation","clsValue","browserPerformanceTimeOrigin","routeName","htmlTreeAsString","dropUndefinedKeys","SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME","SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT","SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE","MAX_INT_AS_BYTES","_performanceCursor","_measurements","_lcpEntry","_clsEntry","startTrackingWebVitals","recordClsStandaloneSpans","performance","fidCleanupCallback","_trackFID","lcpCleanupCallback","_trackLCP","ttfbCleanupCallback","_trackTtfb","clsCleanupCallback","_trackCLS","startTrackingLongTasks","parent","parentOp","parentStartTimestamp","duration","startTrackingLongAnimationFrames","initialScript","invoker","invokerType","sourceURL","sourceFunctionName","sourceCharPosition","startTrackingInteractions","spanOptions","componentName","getComponentName","timeOrigin","addPerformanceEntries","origin","performanceEntries","op","transactionStartTime","_addNavigationSpans","_addMeasureSpans","firstHidden","shouldRecord","_addResourceSpans","_trackNavigator","_addTtfbRequestTimeToMeasurements","fidMark","measurementName","measurement","setMeasurement","_setWebVitalAttributes","requestTime","measureStartTimestamp","startTimeStamp","measureEndTimestamp","_addPerformanceNavigationTiming","_addRequest","eventEnd","_getEndPropertyNameForNavigationTiming","end","start","requestStartTimestamp","responseEndTimestamp","responseStartTimestamp","resourceUrl","parsedUrl","setResourceEntrySizeData","deliveryType","renderBlockingStatus","navigator","connection","source","dataKey","entryVal","responseStart","requestStart","LAST_INTERACTIONS","INTERACTIONS_SPAN_MAP","startTrackingINP","inpCallback","_trackINP","INP_ENTRY_MAP","interactionId","interactionType","spanToUse","registerInpInteractionListener","activeRootSpan","last","responseToSpanId","spanIdToEndTimestamp","defaultRequestInstrumentationOptions","instrumentOutgoingRequests","_options","traceFetch","traceXHR","trackFetchStreamPerformance","shouldCreateSpanForRequest","enableHTTPTimings","tracePropagationTargets","_","shouldAttachHeadersWithTargets","updatedTimestamp","addFetchEndInstrumentationHandler","addFetchInstrumentationHandler","createdSpan","addHTTPTimings","addXhrInstrumentationHandler","xhrCallback","isPerformanceResourceTiming","resourceTimingEntryToSpanData","getAbsoluteTime","resourceTiming","timingSpanData","targetUrl","href","getLocationHref","resolvedUrl","currentOrigin","isSameOriginRequest","stringMatchesSomePattern","isRelativeSameOriginRequest","xhr","sentryXhrData","SENTRY_XHR_DATA_KEY","addTracingHeadersToXhrRequest","setHeaderOnXhr","sentryTraceHeader","sentryBaggageHeader","registerBackgroundTabDetection","cancelledStatus","status","BROWSER_TRACING_INTEGRATION_ID","DEFAULT_BROWSER_TRACING_OPTIONS","browserTracingIntegration","optionalWindowDocument","enableInp","enableLongTask","enableLongAnimationFrame","enableInteractions","enableStandaloneClsSpans","beforeStartSpan","markBackgroundSpan","instrumentPageLoad","instrumentNavigation","_collectWebVitals","latestRoute","_createRouteSpan","isPageloadTransaction","finalStartSpanOptions","SEMANTIC_ATTRIBUTE_SENTRY_SOURCE","idleSpan","setActiveIdleSpan","oldPropagationContext","spanIsSampled","emitFinish","startingUrl","maybeEndActiveSpan","getActiveIdleSpan","getIsolationScope","generateTraceId","traceOptions","getMetaContent","propagationContext","propagationContextFromHeaders","startBrowserTracingPageLoadSpan","addHistoryInstrumentationHandler","to","from","startBrowserTracingNavigationSpan","registerInteractionListener","metaName","metaTag","inflightInteractionSpan","registerInteractionTransaction","activeIdleSpan","currentRootSpanOp","ACTIVE_IDLE_SPAN_PROPERTY","addNonEnumerableProperty","instrumentVueRouter","router","startNavigationSpanFn","isFirstPageLoad","error","captureException","next","isPageLoadNavigation","spanName","transactionSource","lastIndex","getActiveRootSpan","browserTracingIntegration$1","integration","routeLabel","flipper","flipperValues","initFlipper","features","params","flag","sentryBaseConfig"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34]}