{"version":3,"file":"js/853-19647e734665264b4e17.js","mappings":"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","sources":["webpack:///../../src/span.ts","webpack:///../../../../src/browser/metrics/utils.ts","webpack:///../../../../src/browser/metrics/index.ts","webpack:///../../tracing/spanstatus.ts","webpack:///../../src/severity.ts","webpack:///../../tracing/measurement.ts","webpack:///../../eventbuilder.ts","webpack:///../../metrics/metric-summary.ts","webpack:///../../src/api.ts","webpack:///../../instrument/console.ts","webpack:///../../src/hub.ts","webpack:///../../../../../../src/browser/web-vitals/lib/polyfills/interactionCountPolyfill.ts","webpack:///../../../../../src/browser/web-vitals/lib/bindReporter.ts","webpack:///../../../../../src/browser/web-vitals/lib/getActivationStart.ts","webpack:///../../../../../src/browser/web-vitals/lib/initMetric.ts","webpack:///../../../../../src/browser/web-vitals/lib/generateUniqueID.ts","webpack:///../../../../../src/browser/web-vitals/lib/observe.ts","webpack:///../../../../src/browser/web-vitals/getCLS.ts","webpack:///../../../../src/browser/web-vitals/getFID.ts","webpack:///../../../../src/browser/web-vitals/getINP.ts","webpack:///../../../../src/browser/web-vitals/getLCP.ts","webpack:///../../../../src/browser/web-vitals/onTTFB.ts","webpack:///../../browser/instrument.ts","webpack:///../../utils/hasTracingEnabled.ts","webpack:///../../debug-build.ts","webpack:///../../src/constants.ts","webpack:///../../src/promisebuffer.ts","webpack:///../../transports/base.ts","webpack:///../../src/error.ts","webpack:///../../src/eventProcessors.ts","webpack:///../../src/scope.ts","webpack:///../../src/time.ts","webpack:///../../src/exports.ts","webpack:///../../../../src/integrations/breadcrumbs.ts","webpack:///../../constants.ts","webpack:///../../../../../node_modules/@sentry-internal/rrweb/es/rrweb/packages/rrweb-snapshot/es/rrweb-snapshot.js","webpack:///../../../../../node_modules/@sentry-internal/rrweb/es/rrweb/packages/rrweb/src/utils.js","webpack:///../../buildPolyfills/_nullishCoalesce.ts","webpack:///../../../../../node_modules/@sentry-internal/rrweb/es/rrweb/packages/types/dist/rrweb-types.js","webpack:///../../../../../node_modules/@sentry-internal/rrweb/es/rrweb/packages/rrweb/src/record/mutation.js","webpack:///../../../../../node_modules/@sentry-internal/rrweb/es/rrweb/packages/rrweb/src/record/error-handler.js","webpack:///../../../../../node_modules/@sentry-internal/rrweb/es/rrweb/packages/rrweb/src/record/observer.js","webpack:///../../../../../node_modules/@sentry-internal/rrweb/es/rrweb/packages/rrweb/src/record/cross-origin-iframe-mirror.js","webpack:///../../../../../node_modules/@sentry-internal/rrweb/es/rrweb/packages/rrweb/src/record/iframe-manager.js","webpack:///../../../../../node_modules/@sentry-internal/rrweb/es/rrweb/packages/rrweb/src/record/index.js","webpack:///../../../../../node_modules/@sentry-internal/rrweb/es/rrweb/packages/rrweb/src/record/shadow-dom-manager.js","webpack:///../../../../../node_modules/@sentry-internal/rrweb/es/rrweb/packages/rrweb/src/record/observers/canvas/canvas-manager.js","webpack:///../../../../../node_modules/@sentry-internal/rrweb/es/rrweb/packages/rrweb/src/record/stylesheet-manager.js","webpack:///../../../../../node_modules/@sentry-internal/rrweb/es/rrweb/packages/rrweb/src/record/processed-node-manager.js","webpack:///../../util/timestamp.ts","webpack:///../../coreHandlers/util/addBreadcrumbEvent.ts","webpack:///../../coreHandlers/util/domUtils.ts","webpack:///../../coreHandlers/util/onWindowOpen.ts","webpack:///../../coreHandlers/handleClick.ts","webpack:///../../../../../node_modules/@sentry-internal/rrweb-snapshot/es/rrweb-snapshot.js","webpack:///../../types/rrweb.ts","webpack:///../../util/createBreadcrumb.ts","webpack:///../../coreHandlers/util/getAttributesToRecord.ts","webpack:///../../coreHandlers/handleDom.ts","webpack:///../../coreHandlers/handleKeyboardEvent.ts","webpack:///../../util/createPerformanceEntries.ts","webpack:///../../coreHandlers/performanceObserver.ts","webpack:///../../util/log.ts","webpack:///../../eventBuffer/error.ts","webpack:///../../eventBuffer/EventBufferArray.ts","webpack:///../../eventBuffer/WorkerHandler.ts","webpack:///../../eventBuffer/EventBufferCompressionWorker.ts","webpack:///../../eventBuffer/EventBufferProxy.ts","webpack:///../../eventBuffer/index.ts","webpack:///../../../../replay-worker/build/npm/esm/index.js","webpack:///../../../../replay-worker/build/npm/esm/worker.ts","webpack:///../../util/hasSessionStorage.ts","webpack:///../../session/clearSession.ts","webpack:///../../util/isSampled.ts","webpack:///../../session/Session.ts","webpack:///../../session/saveSession.ts","webpack:///../../session/createSession.ts","webpack:///../../util/isExpired.ts","webpack:///../../util/isSessionExpired.ts","webpack:///../../session/shouldRefreshSession.ts","webpack:///../../session/loadOrCreateSession.ts","webpack:///../../session/fetchSession.ts","webpack:///../../util/addEvent.ts","webpack:///../../util/eventUtils.ts","webpack:///../../coreHandlers/handleAfterSendEvent.ts","webpack:///../../coreHandlers/handleBeforeSendEvent.ts","webpack:///../../coreHandlers/handleGlobalEvent.ts","webpack:///../../coreHandlers/util/addFeedbackBreadcrumb.ts","webpack:///../../util/isRrwebError.ts","webpack:///../../coreHandlers/util/shouldSampleForBufferEvent.ts","webpack:///../../util/createPerformanceSpans.ts","webpack:///../../coreHandlers/handleHistory.ts","webpack:///../../coreHandlers/util/addNetworkBreadcrumb.ts","webpack:///../../util/shouldFilterRequest.ts","webpack:///../../coreHandlers/handleXhr.ts","webpack:///../../coreHandlers/util/networkUtils.ts","webpack:///../../coreHandlers/util/fetchUtils.ts","webpack:///../../coreHandlers/util/xhrUtils.ts","webpack:///../../coreHandlers/handleNetworkBreadcrumbs.ts","webpack:///../../coreHandlers/handleFetch.ts","webpack:///../../coreHandlers/handleScope.ts","webpack:///../../util/addGlobalListeners.ts","webpack:///../../util/addMemoryEntry.ts","webpack:///../../util/handleRecordingEmit.ts","webpack:///../../util/createReplayEnvelope.ts","webpack:///../../util/prepareRecordingData.ts","webpack:///../../util/prepareReplayEvent.ts","webpack:///../../util/sendReplayRequest.ts","webpack:///../../util/sendReplay.ts","webpack:///../../util/throttle.ts","webpack:///../../replay.ts","webpack:///../../util/debounce.ts","webpack:///../../util/getPrivacyOptions.ts","webpack:///../../integration.ts","webpack:///../../util/maskAttribute.ts","webpack:///../../util/getReplay.ts","webpack:///../../utils/isSentryRequestUrl.ts","webpack:///../../tracing/transaction.ts","webpack:///../../metrics/utils.ts","webpack:///../../../../src/transports/utils.ts","webpack:///../../../../src/transports/fetch.ts","webpack:///../../userfeedback.ts","webpack:///../../tracing/span.ts","webpack:///../../browser/browserTracingIntegration.ts","webpack:///../../src/supports.ts","webpack:///../../sdk.ts","webpack:///../../src/worldwide.ts","webpack:///../../src/dsn.ts","webpack:///../../src/integration.ts","webpack:///../../src/aggregate-errors.ts","webpack:///../../integrations/functiontostring.ts","webpack:///../../common/fetch.ts","webpack:///../../browser/request.ts","webpack:///../../src/debug-build.ts","webpack:///../../src/isBrowser.ts","webpack:///../../src/sdk.ts","webpack:///../../src/string.ts","webpack:///../../tracing/dynamicSamplingContext.ts","webpack:///../../utils/spanUtils.ts","webpack:///../../../../src/integrations/trycatch.ts","webpack:///../../src/baggage.ts","webpack:///../../src/node.ts","webpack:///../../../../src/integrations/globalhandlers.ts","webpack:///../../utils/handleCallbackErrors.ts","webpack:///../../tracing/trace.ts","webpack:///../../../../src/transports/xhr.ts","webpack:///../../../../src/integrations/httpcontext.ts","webpack:///../../../../../src/browser/web-vitals/lib/onHidden.ts","webpack:///../../src/session.ts","webpack:///../../vendor/supportsHistory.ts","webpack:///../../instrument/history.ts","webpack:///../../tracing/utils.ts","webpack:///../../src/stacktrace.ts","webpack:///../../integrations/inboundfilters.ts","webpack:///../../instrument/xhr.ts","webpack:///../../browser/types.ts","webpack:///../../src/syncpromise.ts","webpack:///../../../../../src/browser/web-vitals/lib/getNavigationEntry.ts","webpack:///../../common/debug-build.ts","webpack:///../../src/semanticAttributes.ts","webpack:///../../instrument/globalError.ts","webpack:///../../stack-parsers.ts","webpack:///../../src/url.ts","webpack:///../../utils/prepareEvent.ts","webpack:///../../metrics/envelope.ts","webpack:///../../src/baseclient.ts","webpack:///../../src/browser.ts","webpack:///../../src/object.ts","webpack:///../../src/tracing.ts","webpack:///../../tracing/errors.ts","webpack:///../../tracing/hubextensions.ts","webpack:///../../utils/getRootSpan.ts","webpack:///../../instrument/dom.ts","webpack:///../../src/version.ts","webpack:///../../src/envelope.ts","webpack:///../../src/ratelimit.ts","webpack:///../../utils/applyScopeDataToEvent.ts","webpack:///../../../../../src/browser/web-vitals/lib/getVisibilityWatcher.ts","webpack:///../../src/misc.ts","webpack:///../../instrument/globalUnhandledRejection.ts","webpack:///../../helpers.ts","webpack:///../../../../src/integrations/dedupe.ts","webpack:///../../instrument/_handlers.ts","webpack:///../../src/is.ts","webpack:///../../src/normalize.ts","webpack:///../../src/memo.ts","webpack:///../../../../src/integrations/linkederrors.ts","webpack:///../../src/env.ts","webpack:///../../tracing/idletransaction.ts","webpack:///../../instrument/fetch.ts","webpack:///../../src/logger.ts","webpack:///../../browser/backgroundtab.ts","webpack:///../../tracing/sampling.ts","webpack:///../../src/clientreport.ts","webpack:///../../client.ts","webpack:///../../utils/sdkMetadata.ts","webpack:///../../buildPolyfills/_optionalChain.ts"],"sourcesContent":["import type { DsnComponents, SpanEnvelope, SpanItem } from '@sentry/types';\nimport type { Span } from '@sentry/types';\nimport { createEnvelope, dsnToString } from '@sentry/utils';\n\n/**\n * Create envelope from Span item.\n */\nexport function createSpanEnvelope(spans: Span[], dsn?: DsnComponents): SpanEnvelope {\n  const headers: SpanEnvelope[0] = {\n    sent_at: new Date().toISOString(),\n  };\n\n  if (dsn) {\n    headers.dsn = dsnToString(dsn);\n  }\n\n  const items = spans.map(createSpanItem);\n  return createEnvelope<SpanEnvelope>(headers, items);\n}\n\nfunction createSpanItem(span: Span): SpanItem {\n  const spanHeaders: SpanItem[0] = {\n    type: 'span',\n  };\n  return [spanHeaders, span];\n}\n","import type { Transaction } from '@sentry/core';\nimport type { Span, SpanContext } from '@sentry/types';\n\n/**\n * Checks if a given value is a valid measurement value.\n */\nexport function isMeasurementValue(value: unknown): value is number {\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 *\n * Note: this will not be possible anymore in v8,\n * unless we do some special handling for browser here...\n */\nexport function _startChild(transaction: Transaction, { startTimestamp, ...ctx }: SpanContext): Span {\n  // eslint-disable-next-line deprecation/deprecation\n  if (startTimestamp && transaction.startTimestamp > startTimestamp) {\n    // eslint-disable-next-line deprecation/deprecation\n    transaction.startTimestamp = startTimestamp;\n  }\n\n  // eslint-disable-next-line deprecation/deprecation\n  return transaction.startChild({\n    startTimestamp,\n    ...ctx,\n  });\n}\n","/* eslint-disable max-lines */\nimport type { IdleTransaction, Transaction } from '@sentry/core';\nimport {\n  Span,\n  getActiveTransaction,\n  getClient,\n  hasTracingEnabled,\n  isValidSampleRate,\n  setMeasurement,\n} from '@sentry/core';\nimport type { ClientOptions, Measurements, SpanContext, TransactionContext } from '@sentry/types';\nimport { browserPerformanceTimeOrigin, getComponentName, htmlTreeAsString, logger, parseUrl } from '@sentry/utils';\n\nimport { spanToJSON } from '@sentry/core';\nimport { DEBUG_BUILD } from '../../common/debug-build';\nimport {\n  addClsInstrumentationHandler,\n  addFidInstrumentationHandler,\n  addInpInstrumentationHandler,\n  addLcpInstrumentationHandler,\n  addPerformanceInstrumentationHandler,\n  addTtfbInstrumentationHandler,\n} from '../instrument';\nimport { WINDOW } from '../types';\nimport { getVisibilityWatcher } from '../web-vitals/lib/getVisibilityWatcher';\nimport type {\n  InteractionRouteNameMapping,\n  NavigatorDeviceMemory,\n  NavigatorNetworkInformation,\n} from '../web-vitals/types';\nimport { _startChild, isMeasurementValue } from './utils';\n\nimport { createSpanEnvelope } from '@sentry/core';\nimport { getNavigationEntry } from '../web-vitals/lib/getNavigationEntry';\n\nconst MAX_INT_AS_BYTES = 2147483647;\n\n/**\n * Converts from milliseconds to seconds\n * @param time time in ms\n */\nfunction msToSec(time: number): number {\n  return time / 1000;\n}\n\nfunction getBrowserPerformanceAPI(): Performance | undefined {\n  // @ts-expect-error we want to make sure all of these are available, even if TS is sure they are\n  return WINDOW && WINDOW.addEventListener && WINDOW.performance;\n}\n\nlet _performanceCursor: number = 0;\n\nlet _measurements: Measurements = {};\nlet _lcpEntry: LargestContentfulPaint | undefined;\nlet _clsEntry: LayoutShift | undefined;\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 */\nexport function startTrackingWebVitals(): () => void {\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 fidCallback = _trackFID();\n    const clsCallback = _trackCLS();\n    const lcpCallback = _trackLCP();\n    const ttfbCallback = _trackTtfb();\n\n    return (): void => {\n      fidCallback();\n      clsCallback();\n      lcpCallback();\n      ttfbCallback();\n    };\n  }\n\n  return () => undefined;\n}\n\n/**\n * Start tracking long tasks.\n */\nexport function startTrackingLongTasks(): void {\n  addPerformanceInstrumentationHandler('longtask', ({ entries }) => {\n    for (const entry of entries) {\n      // eslint-disable-next-line deprecation/deprecation\n      const transaction = getActiveTransaction() as IdleTransaction | undefined;\n      if (!transaction) {\n        return;\n      }\n      const startTime = msToSec((browserPerformanceTimeOrigin as number) + entry.startTime);\n      const duration = msToSec(entry.duration);\n\n      // eslint-disable-next-line deprecation/deprecation\n      transaction.startChild({\n        description: 'Main UI thread blocked',\n        op: 'ui.long-task',\n        origin: 'auto.ui.browser.metrics',\n        startTimestamp: startTime,\n        endTimestamp: startTime + duration,\n      });\n    }\n  });\n}\n\n/**\n * Start tracking interaction events.\n */\nexport function startTrackingInteractions(): void {\n  addPerformanceInstrumentationHandler('event', ({ entries }) => {\n    for (const entry of entries) {\n      // eslint-disable-next-line deprecation/deprecation\n      const transaction = getActiveTransaction() as IdleTransaction | undefined;\n      if (!transaction) {\n        return;\n      }\n\n      if (entry.name === 'click') {\n        const startTime = msToSec((browserPerformanceTimeOrigin as number) + entry.startTime);\n        const duration = msToSec(entry.duration);\n\n        const span: SpanContext = {\n          description: htmlTreeAsString(entry.target),\n          op: `ui.interaction.${entry.name}`,\n          origin: 'auto.ui.browser.metrics',\n          startTimestamp: startTime,\n          endTimestamp: startTime + duration,\n        };\n\n        const componentName = getComponentName(entry.target);\n        if (componentName) {\n          span.attributes = { 'ui.component_name': componentName };\n        }\n\n        // eslint-disable-next-line deprecation/deprecation\n        transaction.startChild(span);\n      }\n    }\n  });\n}\n\n/**\n * Start tracking INP webvital events.\n */\nexport function startTrackingINP(\n  interactionIdtoRouteNameMapping: InteractionRouteNameMapping,\n  interactionsSampleRate: number,\n): () => void {\n  const performance = getBrowserPerformanceAPI();\n  if (performance && browserPerformanceTimeOrigin) {\n    const inpCallback = _trackINP(interactionIdtoRouteNameMapping, interactionsSampleRate);\n\n    return (): void => {\n      inpCallback();\n    };\n  }\n\n  return () => undefined;\n}\n\n/** Starts tracking the Cumulative Layout Shift on the current page. */\nfunction _trackCLS(): () => void {\n  return addClsInstrumentationHandler(({ metric }) => {\n    const entry = metric.entries[metric.entries.length - 1];\n    if (!entry) {\n      return;\n    }\n\n    DEBUG_BUILD && logger.log('[Measurements] Adding CLS');\n    _measurements['cls'] = { value: metric.value, unit: '' };\n    _clsEntry = entry as LayoutShift;\n  }, true);\n}\n\n/** Starts tracking the Largest Contentful Paint on the current page. */\nfunction _trackLCP(): () => void {\n  return addLcpInstrumentationHandler(({ metric }) => {\n    const entry = metric.entries[metric.entries.length - 1];\n    if (!entry) {\n      return;\n    }\n\n    DEBUG_BUILD && logger.log('[Measurements] Adding LCP');\n    _measurements['lcp'] = { value: metric.value, unit: 'millisecond' };\n    _lcpEntry = entry as LargestContentfulPaint;\n  }, true);\n}\n\n/** Starts tracking the First Input Delay on the current page. */\nfunction _trackFID(): () => void {\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 as number);\n    const startTime = msToSec(entry.startTime);\n    DEBUG_BUILD && logger.log('[Measurements] Adding FID');\n    _measurements['fid'] = { value: metric.value, unit: 'millisecond' };\n    _measurements['mark.fid'] = { value: timeOrigin + startTime, unit: 'second' };\n  });\n}\n\nfunction _trackTtfb(): () => void {\n  return addTtfbInstrumentationHandler(({ metric }) => {\n    const entry = metric.entries[metric.entries.length - 1];\n    if (!entry) {\n      return;\n    }\n\n    DEBUG_BUILD && logger.log('[Measurements] Adding TTFB');\n    _measurements['ttfb'] = { value: metric.value, unit: 'millisecond' };\n  });\n}\n\nconst INP_ENTRY_MAP: Record<string, 'click' | 'hover' | 'drag' | 'press'> = {\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  interactionIdToRouteNameMapping: InteractionRouteNameMapping,\n  interactionsSampleRate: number,\n): () => void {\n  return addInpInstrumentationHandler(({ metric }) => {\n    if (metric.value === undefined) {\n      return;\n    }\n    const entry = metric.entries.find(\n      entry => entry.duration === metric.value && INP_ENTRY_MAP[entry.name] !== undefined,\n    );\n    const client = getClient();\n    if (!entry || !client) {\n      return;\n    }\n    const interactionType = INP_ENTRY_MAP[entry.name];\n    const options = client.getOptions();\n    /** Build the INP span, create an envelope from the span, and then send the envelope */\n    const startTime = msToSec((browserPerformanceTimeOrigin as number) + entry.startTime);\n    const duration = msToSec(metric.value);\n    const interaction =\n      entry.interactionId !== undefined ? interactionIdToRouteNameMapping[entry.interactionId] : undefined;\n    if (interaction === undefined) {\n      return;\n    }\n    const { routeName, parentContext, activeTransaction, user, replayId } = interaction;\n    const userDisplay = user !== undefined ? user.email || user.id || user.ip_address : undefined;\n    // eslint-disable-next-line deprecation/deprecation\n    const profileId = activeTransaction !== undefined ? activeTransaction.getProfileId() : undefined;\n    const span = new Span({\n      startTimestamp: startTime,\n      endTimestamp: startTime + duration,\n      op: `ui.interaction.${interactionType}`,\n      name: htmlTreeAsString(entry.target),\n      attributes: {\n        release: options.release,\n        environment: options.environment,\n        transaction: routeName,\n        ...(userDisplay !== undefined && userDisplay !== '' ? { user: userDisplay } : {}),\n        ...(profileId !== undefined ? { profile_id: profileId } : {}),\n        ...(replayId !== undefined ? { replay_id: replayId } : {}),\n      },\n      exclusiveTime: metric.value,\n      measurements: {\n        inp: { value: metric.value, unit: 'millisecond' },\n      },\n    });\n\n    /** Check to see if the span should be sampled */\n    const sampleRate = getSampleRate(parentContext, options, interactionsSampleRate);\n\n    if (!sampleRate) {\n      return;\n    }\n\n    if (Math.random() < (sampleRate as number | boolean)) {\n      const envelope = span ? createSpanEnvelope([span], client.getDsn()) : undefined;\n      const transport = client && client.getTransport();\n      if (transport && envelope) {\n        transport.send(envelope).then(null, reason => {\n          DEBUG_BUILD && logger.error('Error while sending interaction:', reason);\n        });\n      }\n      return;\n    }\n  });\n}\n\n/** Add performance related spans to a transaction */\nexport function addPerformanceEntries(transaction: Transaction): void {\n  const performance = getBrowserPerformanceAPI();\n  if (!performance || !WINDOW.performance.getEntries || !browserPerformanceTimeOrigin) {\n    // Gatekeeper if performance API not available\n    return;\n  }\n\n  DEBUG_BUILD && logger.log('[Tracing] Adding & adjusting spans using Performance API');\n  const timeOrigin = msToSec(browserPerformanceTimeOrigin);\n\n  const performanceEntries = performance.getEntries();\n\n  const { op, start_timestamp: transactionStartTime } = spanToJSON(transaction);\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  performanceEntries.slice(_performanceCursor).forEach((entry: Record<string, any>) => {\n    const startTime = msToSec(entry.startTime);\n    const duration = msToSec(entry.duration);\n\n    // eslint-disable-next-line deprecation/deprecation\n    if (transaction.op === 'navigation' && transactionStartTime && timeOrigin + startTime < transactionStartTime) {\n      return;\n    }\n\n    switch (entry.entryType) {\n      case 'navigation': {\n        _addNavigationSpans(transaction, entry, timeOrigin);\n        break;\n      }\n      case 'mark':\n      case 'paint':\n      case 'measure': {\n        _addMeasureSpans(transaction, entry, startTime, duration, timeOrigin);\n\n        // capture web vitals\n        const firstHidden = getVisibilityWatcher();\n        // Only report if the page wasn't hidden prior to the web vital.\n        const shouldRecord = entry.startTime < firstHidden.firstHiddenTime;\n\n        if (entry.name === 'first-paint' && shouldRecord) {\n          DEBUG_BUILD && logger.log('[Measurements] Adding FP');\n          _measurements['fp'] = { value: entry.startTime, unit: 'millisecond' };\n        }\n        if (entry.name === 'first-contentful-paint' && shouldRecord) {\n          DEBUG_BUILD && logger.log('[Measurements] Adding FCP');\n          _measurements['fcp'] = { value: entry.startTime, unit: 'millisecond' };\n        }\n        break;\n      }\n      case 'resource': {\n        _addResourceSpans(transaction, entry, entry.name as string, startTime, duration, timeOrigin);\n        break;\n      }\n      default:\n      // Ignore other entry types.\n    }\n  });\n\n  _performanceCursor = Math.max(performanceEntries.length - 1, 0);\n\n  _trackNavigator(transaction);\n\n  // Measurements are only available for pageload transactions\n  if (op === 'pageload') {\n    _addTtfbRequestTimeToMeasurements(_measurements);\n\n    ['fcp', 'fp', 'lcp'].forEach(name => {\n      if (!_measurements[name] || !transactionStartTime || timeOrigin >= transactionStartTime) {\n        return;\n      }\n      // The web vitals, fcp, fp, lcp, and ttfb, all measure relative to timeOrigin.\n      // Unfortunately, timeOrigin is not captured within the transaction span data, so these web vitals will need\n      // to be adjusted to be relative to transaction.startTimestamp.\n      const oldValue = _measurements[name].value;\n      const measurementTimestamp = timeOrigin + msToSec(oldValue);\n\n      // normalizedValue should be in milliseconds\n      const normalizedValue = Math.abs((measurementTimestamp - transactionStartTime) * 1000);\n      const delta = normalizedValue - oldValue;\n\n      DEBUG_BUILD && logger.log(`[Measurements] Normalized ${name} from ${oldValue} to ${normalizedValue} (${delta})`);\n      _measurements[name].value = normalizedValue;\n    });\n\n    const fidMark = _measurements['mark.fid'];\n    if (fidMark && _measurements['fid']) {\n      // create span for FID\n      _startChild(transaction, {\n        description: 'first input delay',\n        endTimestamp: fidMark.value + msToSec(_measurements['fid'].value),\n        op: 'ui.action',\n        origin: 'auto.ui.browser.metrics',\n        startTimestamp: fidMark.value,\n      });\n\n      // Delete mark.fid as we don't want it to be part of final payload\n      delete _measurements['mark.fid'];\n    }\n\n    // If FCP is not recorded we should not record the cls value\n    // according to the new definition of CLS.\n    if (!('fcp' in _measurements)) {\n      delete _measurements.cls;\n    }\n\n    Object.keys(_measurements).forEach(measurementName => {\n      setMeasurement(measurementName, _measurements[measurementName].value, _measurements[measurementName].unit);\n    });\n\n    _tagMetricInfo(transaction);\n  }\n\n  _lcpEntry = undefined;\n  _clsEntry = undefined;\n  _measurements = {};\n}\n\n/** Create measure related spans */\nexport function _addMeasureSpans(\n  transaction: Transaction,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  entry: Record<string, any>,\n  startTime: number,\n  duration: number,\n  timeOrigin: number,\n): number {\n  const measureStartTimestamp = timeOrigin + startTime;\n  const measureEndTimestamp = measureStartTimestamp + duration;\n\n  _startChild(transaction, {\n    description: entry.name as string,\n    endTimestamp: measureEndTimestamp,\n    op: entry.entryType as string,\n    origin: 'auto.resource.browser.metrics',\n    startTimestamp: measureStartTimestamp,\n  });\n\n  return measureStartTimestamp;\n}\n\n/** Instrument navigation entries */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _addNavigationSpans(transaction: Transaction, entry: Record<string, any>, timeOrigin: number): void {\n  ['unloadEvent', 'redirect', 'domContentLoadedEvent', 'loadEvent', 'connect'].forEach(event => {\n    _addPerformanceNavigationTiming(transaction, entry, event, timeOrigin);\n  });\n  _addPerformanceNavigationTiming(transaction, entry, 'secureConnection', timeOrigin, 'TLS/SSL', 'connectEnd');\n  _addPerformanceNavigationTiming(transaction, entry, 'fetch', timeOrigin, 'cache', 'domainLookupStart');\n  _addPerformanceNavigationTiming(transaction, entry, 'domainLookup', timeOrigin, 'DNS');\n  _addRequest(transaction, entry, timeOrigin);\n}\n\n/** Create performance navigation related spans */\nfunction _addPerformanceNavigationTiming(\n  transaction: Transaction,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  entry: Record<string, any>,\n  event: string,\n  timeOrigin: number,\n  description?: string,\n  eventEnd?: string,\n): void {\n  const end = eventEnd ? (entry[eventEnd] as number | undefined) : (entry[`${event}End`] as number | undefined);\n  const start = entry[`${event}Start`] as number | undefined;\n  if (!start || !end) {\n    return;\n  }\n  _startChild(transaction, {\n    op: 'browser',\n    origin: 'auto.browser.browser.metrics',\n    description: description || event,\n    startTimestamp: timeOrigin + msToSec(start),\n    endTimestamp: timeOrigin + msToSec(end),\n  });\n}\n\n/** Create request and response related spans */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _addRequest(transaction: Transaction, entry: Record<string, any>, timeOrigin: number): void {\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 transaction if it contained faulty spans.\n    _startChild(transaction, {\n      op: 'browser',\n      origin: 'auto.browser.browser.metrics',\n      description: 'request',\n      startTimestamp: timeOrigin + msToSec(entry.requestStart as number),\n      endTimestamp: timeOrigin + msToSec(entry.responseEnd as number),\n    });\n\n    _startChild(transaction, {\n      op: 'browser',\n      origin: 'auto.browser.browser.metrics',\n      description: 'response',\n      startTimestamp: timeOrigin + msToSec(entry.responseStart as number),\n      endTimestamp: timeOrigin + msToSec(entry.responseEnd as number),\n    });\n  }\n}\n\nexport interface ResourceEntry extends Record<string, unknown> {\n  initiatorType?: string;\n  transferSize?: number;\n  encodedBodySize?: number;\n  decodedBodySize?: number;\n  renderBlockingStatus?: string;\n}\n\n/** Create resource-related spans */\nexport function _addResourceSpans(\n  transaction: Transaction,\n  entry: ResourceEntry,\n  resourceUrl: string,\n  startTime: number,\n  duration: number,\n  timeOrigin: number,\n): void {\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  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const data: Record<string, any> = {};\n  setResourceEntrySizeData(data, entry, 'transferSize', 'http.response_transfer_size');\n  setResourceEntrySizeData(data, entry, 'encodedBodySize', 'http.response_content_length');\n  setResourceEntrySizeData(data, entry, 'decodedBodySize', 'http.decoded_response_content_length');\n\n  if ('renderBlockingStatus' in entry) {\n    data['resource.render_blocking_status'] = entry.renderBlockingStatus;\n  }\n  if (parsedUrl.protocol) {\n    data['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    data['server.address'] = parsedUrl.host;\n  }\n\n  data['url.same_origin'] = resourceUrl.includes(WINDOW.location.origin);\n\n  const startTimestamp = timeOrigin + startTime;\n  const endTimestamp = startTimestamp + duration;\n\n  _startChild(transaction, {\n    description: resourceUrl.replace(WINDOW.location.origin, ''),\n    endTimestamp,\n    op: entry.initiatorType ? `resource.${entry.initiatorType}` : 'resource.other',\n    origin: 'auto.resource.browser.metrics',\n    startTimestamp,\n    data,\n  });\n}\n\n/**\n * Capture the information of the user agent.\n */\nfunction _trackNavigator(transaction: Transaction): void {\n  const navigator = WINDOW.navigator as null | (Navigator & NavigatorNetworkInformation & NavigatorDeviceMemory);\n  if (!navigator) {\n    return;\n  }\n\n  // track network connectivity\n  const connection = navigator.connection;\n  if (connection) {\n    if (connection.effectiveType) {\n      // TODO: Can we rewrite this to an attribute?\n      // eslint-disable-next-line deprecation/deprecation\n      transaction.setTag('effectiveConnectionType', connection.effectiveType);\n    }\n\n    if (connection.type) {\n      // TODO: Can we rewrite this to an attribute?\n      // eslint-disable-next-line deprecation/deprecation\n      transaction.setTag('connectionType', connection.type);\n    }\n\n    if (isMeasurementValue(connection.rtt)) {\n      _measurements['connection.rtt'] = { value: connection.rtt, unit: 'millisecond' };\n    }\n  }\n\n  if (isMeasurementValue(navigator.deviceMemory)) {\n    // TODO: Can we rewrite this to an attribute?\n    // eslint-disable-next-line deprecation/deprecation\n    transaction.setTag('deviceMemory', `${navigator.deviceMemory} GB`);\n  }\n\n  if (isMeasurementValue(navigator.hardwareConcurrency)) {\n    // TODO: Can we rewrite this to an attribute?\n    // eslint-disable-next-line deprecation/deprecation\n    transaction.setTag('hardwareConcurrency', String(navigator.hardwareConcurrency));\n  }\n}\n\n/** Add LCP / CLS data to transaction to allow debugging */\nfunction _tagMetricInfo(transaction: Transaction): void {\n  if (_lcpEntry) {\n    DEBUG_BUILD && logger.log('[Measurements] Adding LCP Data');\n\n    // Capture Properties of the LCP element that contributes to the LCP.\n\n    if (_lcpEntry.element) {\n      // TODO: Can we rewrite this to an attribute?\n      // eslint-disable-next-line deprecation/deprecation\n      transaction.setTag('lcp.element', htmlTreeAsString(_lcpEntry.element));\n    }\n\n    if (_lcpEntry.id) {\n      // TODO: Can we rewrite this to an attribute?\n      // eslint-disable-next-line deprecation/deprecation\n      transaction.setTag('lcp.id', _lcpEntry.id);\n    }\n\n    if (_lcpEntry.url) {\n      // Trim URL to the first 200 characters.\n      // TODO: Can we rewrite this to an attribute?\n      // eslint-disable-next-line deprecation/deprecation\n      transaction.setTag('lcp.url', _lcpEntry.url.trim().slice(0, 200));\n    }\n\n    // TODO: Can we rewrite this to an attribute?\n    // eslint-disable-next-line deprecation/deprecation\n    transaction.setTag('lcp.size', _lcpEntry.size);\n  }\n\n  // See: https://developer.mozilla.org/en-US/docs/Web/API/LayoutShift\n  if (_clsEntry && _clsEntry.sources) {\n    DEBUG_BUILD && logger.log('[Measurements] Adding CLS Data');\n    _clsEntry.sources.forEach((source, index) =>\n      // TODO: Can we rewrite this to an attribute?\n      // eslint-disable-next-line deprecation/deprecation\n      transaction.setTag(`cls.source.${index + 1}`, htmlTreeAsString(source.node)),\n    );\n  }\n}\n\nfunction setResourceEntrySizeData(\n  data: Record<string, unknown>,\n  entry: ResourceEntry,\n  key: keyof Pick<ResourceEntry, 'transferSize' | 'encodedBodySize' | 'decodedBodySize'>,\n  dataKey: 'http.response_transfer_size' | 'http.response_content_length' | 'http.decoded_response_content_length',\n): void {\n  const entryVal = entry[key];\n  if (entryVal != null && entryVal < MAX_INT_AS_BYTES) {\n    data[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: Measurements): void {\n  const navEntry = getNavigationEntry();\n  if (!navEntry) {\n    return;\n  }\n\n  const { responseStart, requestStart } = navEntry;\n\n  if (requestStart <= responseStart) {\n    DEBUG_BUILD && logger.log('[Measurements] Adding TTFB Request Time');\n    _measurements['ttfb.requestTime'] = {\n      value: responseStart - requestStart,\n      unit: 'millisecond',\n    };\n  }\n}\n\n/** Taken from @sentry/core sampling.ts */\nfunction getSampleRate(\n  transactionContext: TransactionContext | undefined,\n  options: ClientOptions,\n  interactionsSampleRate: number,\n): number | boolean {\n  if (!hasTracingEnabled(options)) {\n    return false;\n  }\n  let sampleRate;\n  if (transactionContext !== undefined && typeof options.tracesSampler === 'function') {\n    sampleRate = options.tracesSampler({\n      transactionContext,\n      name: transactionContext.name,\n      parentSampled: transactionContext.parentSampled,\n      attributes: {\n        // eslint-disable-next-line deprecation/deprecation\n        ...transactionContext.data,\n        ...transactionContext.attributes,\n      },\n      location: WINDOW.location,\n    });\n  } else if (transactionContext !== undefined && transactionContext.sampled !== undefined) {\n    sampleRate = transactionContext.sampled;\n  } else if (typeof options.tracesSampleRate !== 'undefined') {\n    sampleRate = options.tracesSampleRate;\n  } else {\n    sampleRate = 1;\n  }\n  if (!isValidSampleRate(sampleRate)) {\n    DEBUG_BUILD && logger.warn('[Tracing] Discarding interaction span because of invalid sample rate.');\n    return false;\n  }\n  if (sampleRate === true) {\n    return interactionsSampleRate;\n  } else if (sampleRate === false) {\n    return 0;\n  }\n  return sampleRate * interactionsSampleRate;\n}\n","import type { Span } from '@sentry/types';\n\n/** The status of an Span.\n *\n * @deprecated Use string literals - if you require type casting, cast to SpanStatusType type\n */\nexport enum SpanStatus {\n  /** The operation completed successfully. */\n  Ok = 'ok',\n  /** Deadline expired before operation could complete. */\n  DeadlineExceeded = 'deadline_exceeded',\n  /** 401 Unauthorized (actually does mean unauthenticated according to RFC 7235) */\n  Unauthenticated = 'unauthenticated',\n  /** 403 Forbidden */\n  PermissionDenied = 'permission_denied',\n  /** 404 Not Found. Some requested entity (file or directory) was not found. */\n  NotFound = 'not_found',\n  /** 429 Too Many Requests */\n  ResourceExhausted = 'resource_exhausted',\n  /** Client specified an invalid argument. 4xx. */\n  InvalidArgument = 'invalid_argument',\n  /** 501 Not Implemented */\n  Unimplemented = 'unimplemented',\n  /** 503 Service Unavailable */\n  Unavailable = 'unavailable',\n  /** Other/generic 5xx. */\n  InternalError = 'internal_error',\n  /** Unknown. Any non-standard HTTP status code. */\n  UnknownError = 'unknown_error',\n  /** The operation was cancelled (typically by the user). */\n  Cancelled = 'cancelled',\n  /** Already exists (409) */\n  AlreadyExists = 'already_exists',\n  /** Operation was rejected because the system is not in a state required for the operation's */\n  FailedPrecondition = 'failed_precondition',\n  /** The operation was aborted, typically due to a concurrency issue. */\n  Aborted = 'aborted',\n  /** Operation was attempted past the valid range. */\n  OutOfRange = 'out_of_range',\n  /** Unrecoverable data loss or corruption */\n  DataLoss = 'data_loss',\n}\n\nexport type SpanStatusType =\n  /** The operation completed successfully. */\n  | 'ok'\n  /** Deadline expired before operation could complete. */\n  | 'deadline_exceeded'\n  /** 401 Unauthorized (actually does mean unauthenticated according to RFC 7235) */\n  | 'unauthenticated'\n  /** 403 Forbidden */\n  | 'permission_denied'\n  /** 404 Not Found. Some requested entity (file or directory) was not found. */\n  | 'not_found'\n  /** 429 Too Many Requests */\n  | 'resource_exhausted'\n  /** Client specified an invalid argument. 4xx. */\n  | 'invalid_argument'\n  /** 501 Not Implemented */\n  | 'unimplemented'\n  /** 503 Service Unavailable */\n  | 'unavailable'\n  /** Other/generic 5xx. */\n  | 'internal_error'\n  /** Unknown. Any non-standard HTTP status code. */\n  | 'unknown_error'\n  /** The operation was cancelled (typically by the user). */\n  | 'cancelled'\n  /** Already exists (409) */\n  | 'already_exists'\n  /** Operation was rejected because the system is not in a state required for the operation's */\n  | 'failed_precondition'\n  /** The operation was aborted, typically due to a concurrency issue. */\n  | 'aborted'\n  /** Operation was attempted past the valid range. */\n  | 'out_of_range'\n  /** Unrecoverable data loss or corruption */\n  | 'data_loss';\n\n/**\n * Converts a HTTP status code into a {@link SpanStatusType}.\n *\n * @param httpStatus The HTTP response status code.\n * @returns The span status or unknown_error.\n */\nexport function getSpanStatusFromHttpCode(httpStatus: number): SpanStatusType {\n  if (httpStatus < 400 && httpStatus >= 100) {\n    return 'ok';\n  }\n\n  if (httpStatus >= 400 && httpStatus < 500) {\n    switch (httpStatus) {\n      case 401:\n        return 'unauthenticated';\n      case 403:\n        return 'permission_denied';\n      case 404:\n        return 'not_found';\n      case 409:\n        return 'already_exists';\n      case 413:\n        return 'failed_precondition';\n      case 429:\n        return 'resource_exhausted';\n      default:\n        return 'invalid_argument';\n    }\n  }\n\n  if (httpStatus >= 500 && httpStatus < 600) {\n    switch (httpStatus) {\n      case 501:\n        return 'unimplemented';\n      case 503:\n        return 'unavailable';\n      case 504:\n        return 'deadline_exceeded';\n      default:\n        return 'internal_error';\n    }\n  }\n\n  return 'unknown_error';\n}\n\n/**\n * Converts a HTTP status code into a {@link SpanStatusType}.\n *\n * @deprecated Use {@link spanStatusFromHttpCode} instead.\n * This export will be removed in v8 as the signature contains a typo.\n *\n * @param httpStatus The HTTP response status code.\n * @returns The span status or unknown_error.\n */\nexport const spanStatusfromHttpCode = getSpanStatusFromHttpCode;\n\n/**\n * Sets the Http status attributes on the current span based on the http code.\n * Additionally, the span's status is updated, depending on the http code.\n */\nexport function setHttpStatus(span: Span, httpStatus: number): void {\n  // TODO (v8): Remove these calls\n  // Relay does not require us to send the status code as a tag\n  // For now, just because users might expect it to land as a tag we keep sending it.\n  // Same with data.\n  // In v8, we replace both, simply with\n  // span.setAttribute('http.response.status_code', httpStatus);\n\n  // eslint-disable-next-line deprecation/deprecation\n  span.setTag('http.status_code', String(httpStatus));\n  // eslint-disable-next-line deprecation/deprecation\n  span.setData('http.response.status_code', httpStatus);\n\n  const spanStatus = getSpanStatusFromHttpCode(httpStatus);\n  if (spanStatus !== 'unknown_error') {\n    span.setStatus(spanStatus);\n  }\n}\n","/* eslint-disable deprecation/deprecation */\nimport type { Severity, SeverityLevel } from '@sentry/types';\n\n// Note: Ideally the `SeverityLevel` type would be derived from `validSeverityLevels`, but that would mean either\n//\n// a) moving `validSeverityLevels` to `@sentry/types`,\n// b) moving the`SeverityLevel` type here, or\n// c) importing `validSeverityLevels` from here into `@sentry/types`.\n//\n// Option A would make `@sentry/types` a runtime dependency of `@sentry/utils` (not good), and options B and C would\n// create a circular dependency between `@sentry/types` and `@sentry/utils` (also not good). So a TODO accompanying the\n// type, reminding anyone who changes it to change this list also, will have to do.\n\nexport const validSeverityLevels = ['fatal', 'error', 'warning', 'log', 'info', 'debug'];\n\n/**\n * Converts a string-based level into a member of the deprecated {@link Severity} enum.\n *\n * @deprecated `severityFromString` is deprecated. Please use `severityLevelFromString` instead.\n *\n * @param level String representation of Severity\n * @returns Severity\n */\nexport function severityFromString(level: Severity | SeverityLevel | string): Severity {\n  return severityLevelFromString(level) as Severity;\n}\n\n/**\n * Converts a string-based level into a `SeverityLevel`, normalizing it along the way.\n *\n * @param level String representation of desired `SeverityLevel`.\n * @returns The `SeverityLevel` corresponding to the given string, or 'log' if the string isn't a valid level.\n */\nexport function severityLevelFromString(level: SeverityLevel | string): SeverityLevel {\n  return (level === 'warn' ? 'warning' : validSeverityLevels.includes(level) ? level : 'log') as SeverityLevel;\n}\n","import type { MeasurementUnit } from '@sentry/types';\n\nimport { getActiveTransaction } from './utils';\n\n/**\n * Adds a measurement to the current active transaction.\n */\nexport function setMeasurement(name: string, value: number, unit: MeasurementUnit): void {\n  // eslint-disable-next-line deprecation/deprecation\n  const transaction = getActiveTransaction();\n  if (transaction) {\n    // eslint-disable-next-line deprecation/deprecation\n    transaction.setMeasurement(name, value, unit);\n  }\n}\n","import { getClient } from '@sentry/core';\nimport type {\n  Event,\n  EventHint,\n  Exception,\n  ParameterizedString,\n  Severity,\n  SeverityLevel,\n  StackFrame,\n  StackParser,\n} from '@sentry/types';\nimport {\n  addExceptionMechanism,\n  addExceptionTypeValue,\n  extractExceptionKeysForMessage,\n  isDOMError,\n  isDOMException,\n  isError,\n  isErrorEvent,\n  isEvent,\n  isParameterizedString,\n  isPlainObject,\n  normalizeToSize,\n  resolvedSyncPromise,\n} from '@sentry/utils';\n\ntype Prototype = { constructor: (...args: unknown[]) => unknown };\n\n/**\n * This function creates an exception from a JavaScript Error\n */\nexport function exceptionFromError(stackParser: StackParser, ex: Error): Exception {\n  // Get the frames first since Opera can lose the stack if we touch anything else first\n  const frames = parseStackFrames(stackParser, ex);\n\n  const exception: Exception = {\n    type: ex && ex.name,\n    value: extractMessage(ex),\n  };\n\n  if (frames.length) {\n    exception.stacktrace = { frames };\n  }\n\n  if (exception.type === undefined && exception.value === '') {\n    exception.value = 'Unrecoverable error caught';\n  }\n\n  return exception;\n}\n\n/**\n * @hidden\n */\nexport function eventFromPlainObject(\n  stackParser: StackParser,\n  exception: Record<string, unknown>,\n  syntheticException?: Error,\n  isUnhandledRejection?: boolean,\n): Event {\n  const client = getClient();\n  const normalizeDepth = client && client.getOptions().normalizeDepth;\n\n  const event: Event = {\n    exception: {\n      values: [\n        {\n          type: isEvent(exception) ? exception.constructor.name : isUnhandledRejection ? 'UnhandledRejection' : 'Error',\n          value: getNonErrorObjectExceptionValue(exception, { isUnhandledRejection }),\n        },\n      ],\n    },\n    extra: {\n      __serialized__: normalizeToSize(exception, normalizeDepth),\n    },\n  };\n\n  if (syntheticException) {\n    const frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      // event.exception.values[0] has been set above\n      (event.exception as { values: Exception[] }).values[0].stacktrace = { frames };\n    }\n  }\n\n  return event;\n}\n\n/**\n * @hidden\n */\nexport function eventFromError(stackParser: StackParser, ex: Error): Event {\n  return {\n    exception: {\n      values: [exceptionFromError(stackParser, ex)],\n    },\n  };\n}\n\n/** Parses stack frames from an error */\nexport function parseStackFrames(\n  stackParser: StackParser,\n  ex: Error & { framesToPop?: number; stacktrace?: string },\n): StackFrame[] {\n  // Access and store the stacktrace property before doing ANYTHING\n  // else to it because Opera is not very good at providing it\n  // reliably in other circumstances.\n  const stacktrace = ex.stacktrace || ex.stack || '';\n\n  const popSize = getPopSize(ex);\n\n  try {\n    return stackParser(stacktrace, popSize);\n  } catch (e) {\n    // no-empty\n  }\n\n  return [];\n}\n\n// Based on our own mapping pattern - https://github.com/getsentry/sentry/blob/9f08305e09866c8bd6d0c24f5b0aabdd7dd6c59c/src/sentry/lang/javascript/errormapping.py#L83-L108\nconst reactMinifiedRegexp = /Minified React error #\\d+;/i;\n\nfunction getPopSize(ex: Error & { framesToPop?: number }): number {\n  if (ex) {\n    if (typeof ex.framesToPop === 'number') {\n      return ex.framesToPop;\n    }\n\n    if (reactMinifiedRegexp.test(ex.message)) {\n      return 1;\n    }\n  }\n\n  return 0;\n}\n\n/**\n * There are cases where stacktrace.message is an Event object\n * https://github.com/getsentry/sentry-javascript/issues/1949\n * In this specific case we try to extract stacktrace.message.error.message\n */\nfunction extractMessage(ex: Error & { message: { error?: Error } }): string {\n  const message = ex && ex.message;\n  if (!message) {\n    return 'No error message';\n  }\n  if (message.error && typeof message.error.message === 'string') {\n    return message.error.message;\n  }\n  return message;\n}\n\n/**\n * Creates an {@link Event} from all inputs to `captureException` and non-primitive inputs to `captureMessage`.\n * @hidden\n */\nexport function eventFromException(\n  stackParser: StackParser,\n  exception: unknown,\n  hint?: EventHint,\n  attachStacktrace?: boolean,\n): PromiseLike<Event> {\n  const syntheticException = (hint && hint.syntheticException) || undefined;\n  const event = eventFromUnknownInput(stackParser, exception, syntheticException, attachStacktrace);\n  addExceptionMechanism(event); // defaults to { type: 'generic', handled: true }\n  event.level = 'error';\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * Builds and Event from a Message\n * @hidden\n */\nexport function eventFromMessage(\n  stackParser: StackParser,\n  message: ParameterizedString,\n  // eslint-disable-next-line deprecation/deprecation\n  level: Severity | SeverityLevel = 'info',\n  hint?: EventHint,\n  attachStacktrace?: boolean,\n): PromiseLike<Event> {\n  const syntheticException = (hint && hint.syntheticException) || undefined;\n  const event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n  event.level = level;\n  if (hint && hint.event_id) {\n    event.event_id = hint.event_id;\n  }\n  return resolvedSyncPromise(event);\n}\n\n/**\n * @hidden\n */\nexport function eventFromUnknownInput(\n  stackParser: StackParser,\n  exception: unknown,\n  syntheticException?: Error,\n  attachStacktrace?: boolean,\n  isUnhandledRejection?: boolean,\n): Event {\n  let event: Event;\n\n  if (isErrorEvent(exception as ErrorEvent) && (exception as ErrorEvent).error) {\n    // If it is an ErrorEvent with `error` property, extract it to get actual Error\n    const errorEvent = exception as ErrorEvent;\n    return eventFromError(stackParser, errorEvent.error as Error);\n  }\n\n  // If it is a `DOMError` (which is a legacy API, but still supported in some browsers) then we just extract the name\n  // and message, as it doesn't provide anything else. According to the spec, all `DOMExceptions` should also be\n  // `Error`s, but that's not the case in IE11, so in that case we treat it the same as we do a `DOMError`.\n  //\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMError\n  // https://developer.mozilla.org/en-US/docs/Web/API/DOMException\n  // https://webidl.spec.whatwg.org/#es-DOMException-specialness\n  if (isDOMError(exception) || isDOMException(exception as DOMException)) {\n    const domException = exception as DOMException;\n\n    if ('stack' in (exception as Error)) {\n      event = eventFromError(stackParser, exception as Error);\n    } else {\n      const name = domException.name || (isDOMError(domException) ? 'DOMError' : 'DOMException');\n      const message = domException.message ? `${name}: ${domException.message}` : name;\n      event = eventFromString(stackParser, message, syntheticException, attachStacktrace);\n      addExceptionTypeValue(event, message);\n    }\n    if ('code' in domException) {\n      // eslint-disable-next-line deprecation/deprecation\n      event.tags = { ...event.tags, 'DOMException.code': `${domException.code}` };\n    }\n\n    return event;\n  }\n  if (isError(exception)) {\n    // we have a real Error object, do nothing\n    return eventFromError(stackParser, exception);\n  }\n  if (isPlainObject(exception) || isEvent(exception)) {\n    // If it's a plain object or an instance of `Event` (the built-in JS kind, not this SDK's `Event` type), serialize\n    // it manually. This will allow us to group events based on top-level keys which is much better than creating a new\n    // group on any key/value change.\n    const objectException = exception as Record<string, unknown>;\n    event = eventFromPlainObject(stackParser, objectException, syntheticException, isUnhandledRejection);\n    addExceptionMechanism(event, {\n      synthetic: true,\n    });\n    return event;\n  }\n\n  // If none of previous checks were valid, then it means that it's not:\n  // - an instance of DOMError\n  // - an instance of DOMException\n  // - an instance of Event\n  // - an instance of Error\n  // - a valid ErrorEvent (one with an error property)\n  // - a plain Object\n  //\n  // So bail out and capture it as a simple message:\n  event = eventFromString(stackParser, exception as string, syntheticException, attachStacktrace);\n  addExceptionTypeValue(event, `${exception}`, undefined);\n  addExceptionMechanism(event, {\n    synthetic: true,\n  });\n\n  return event;\n}\n\n/**\n * @hidden\n */\nexport function eventFromString(\n  stackParser: StackParser,\n  message: ParameterizedString,\n  syntheticException?: Error,\n  attachStacktrace?: boolean,\n): Event {\n  const event: Event = {};\n\n  if (attachStacktrace && syntheticException) {\n    const frames = parseStackFrames(stackParser, syntheticException);\n    if (frames.length) {\n      event.exception = {\n        values: [{ value: message, stacktrace: { frames } }],\n      };\n    }\n  }\n\n  if (isParameterizedString(message)) {\n    const { __sentry_template_string__, __sentry_template_values__ } = message;\n\n    event.logentry = {\n      message: __sentry_template_string__,\n      params: __sentry_template_values__,\n    };\n    return event;\n  }\n\n  event.message = message;\n  return event;\n}\n\nfunction getNonErrorObjectExceptionValue(\n  exception: Record<string, unknown>,\n  { isUnhandledRejection }: { isUnhandledRejection?: boolean },\n): string {\n  const keys = extractExceptionKeysForMessage(exception);\n  const captureType = isUnhandledRejection ? 'promise rejection' : 'exception';\n\n  // Some ErrorEvent instances do not have an `error` property, which is why they are not handled before\n  // We still want to try to get a decent message for these cases\n  if (isErrorEvent(exception)) {\n    return `Event \\`ErrorEvent\\` captured as ${captureType} with message \\`${exception.message}\\``;\n  }\n\n  if (isEvent(exception)) {\n    const className = getObjectClassName(exception);\n    return `Event \\`${className}\\` (type=${exception.type}) captured as ${captureType}`;\n  }\n\n  return `Object captured as ${captureType} with keys: ${keys}`;\n}\n\nfunction getObjectClassName(obj: unknown): string | undefined | void {\n  try {\n    const prototype: Prototype | null = Object.getPrototypeOf(obj);\n    return prototype ? prototype.constructor.name : undefined;\n  } catch (e) {\n    // ignore errors here\n  }\n}\n","import type { MeasurementUnit, Span } from '@sentry/types';\nimport type { MetricSummary } from '@sentry/types';\nimport type { Primitive } from '@sentry/types';\nimport { dropUndefinedKeys } from '@sentry/utils';\nimport { getActiveSpan } from '../tracing';\nimport type { MetricType } from './types';\n\n/**\n * key: bucketKey\n * value: [exportKey, MetricSummary]\n */\ntype MetricSummaryStorage = Map<string, [string, MetricSummary]>;\n\nlet SPAN_METRIC_SUMMARY: WeakMap<Span, MetricSummaryStorage> | undefined;\n\nfunction getMetricStorageForSpan(span: Span): MetricSummaryStorage | undefined {\n  return SPAN_METRIC_SUMMARY ? SPAN_METRIC_SUMMARY.get(span) : undefined;\n}\n\n/**\n * Fetches the metric summary if it exists for the passed span\n */\nexport function getMetricSummaryJsonForSpan(span: Span): Record<string, Array<MetricSummary>> | undefined {\n  const storage = getMetricStorageForSpan(span);\n\n  if (!storage) {\n    return undefined;\n  }\n  const output: Record<string, Array<MetricSummary>> = {};\n\n  for (const [, [exportKey, summary]] of storage) {\n    if (!output[exportKey]) {\n      output[exportKey] = [];\n    }\n\n    output[exportKey].push(dropUndefinedKeys(summary));\n  }\n\n  return output;\n}\n\n/**\n * Updates the metric summary on the currently active span\n */\nexport function updateMetricSummaryOnActiveSpan(\n  metricType: MetricType,\n  sanitizedName: string,\n  value: number,\n  unit: MeasurementUnit,\n  tags: Record<string, Primitive>,\n  bucketKey: string,\n): void {\n  const span = getActiveSpan();\n  if (span) {\n    const storage = getMetricStorageForSpan(span) || new Map<string, [string, MetricSummary]>();\n\n    const exportKey = `${metricType}:${sanitizedName}@${unit}`;\n    const bucketItem = storage.get(bucketKey);\n\n    if (bucketItem) {\n      const [, summary] = bucketItem;\n      storage.set(bucketKey, [\n        exportKey,\n        {\n          min: Math.min(summary.min, value),\n          max: Math.max(summary.max, value),\n          count: (summary.count += 1),\n          sum: (summary.sum += value),\n          tags: summary.tags,\n        },\n      ]);\n    } else {\n      storage.set(bucketKey, [\n        exportKey,\n        {\n          min: value,\n          max: value,\n          count: 1,\n          sum: value,\n          tags,\n        },\n      ]);\n    }\n\n    if (!SPAN_METRIC_SUMMARY) {\n      SPAN_METRIC_SUMMARY = new WeakMap();\n    }\n\n    SPAN_METRIC_SUMMARY.set(span, storage);\n  }\n}\n","import type { ClientOptions, DsnComponents, DsnLike, SdkInfo } from '@sentry/types';\nimport { dsnToString, makeDsn, urlEncode } from '@sentry/utils';\n\nconst SENTRY_API_VERSION = '7';\n\n/** Returns the prefix to construct Sentry ingestion API endpoints. */\nfunction getBaseApiEndpoint(dsn: DsnComponents): string {\n  const protocol = dsn.protocol ? `${dsn.protocol}:` : '';\n  const port = dsn.port ? `:${dsn.port}` : '';\n  return `${protocol}//${dsn.host}${port}${dsn.path ? `/${dsn.path}` : ''}/api/`;\n}\n\n/** Returns the ingest API endpoint for target. */\nfunction _getIngestEndpoint(dsn: DsnComponents): string {\n  return `${getBaseApiEndpoint(dsn)}${dsn.projectId}/envelope/`;\n}\n\n/** Returns a URL-encoded string with auth config suitable for a query string. */\nfunction _encodedAuth(dsn: DsnComponents, sdkInfo: SdkInfo | undefined): string {\n  return urlEncode({\n    // We send only the minimum set of required information. See\n    // https://github.com/getsentry/sentry-javascript/issues/2572.\n    sentry_key: dsn.publicKey,\n    sentry_version: SENTRY_API_VERSION,\n    ...(sdkInfo && { sentry_client: `${sdkInfo.name}/${sdkInfo.version}` }),\n  });\n}\n\n/**\n * Returns the envelope endpoint URL with auth in the query string.\n *\n * Sending auth as part of the query string and not as custom HTTP headers avoids CORS preflight requests.\n */\nexport function getEnvelopeEndpointWithUrlEncodedAuth(\n  dsn: DsnComponents,\n  // TODO (v8): Remove `tunnelOrOptions` in favor of `options`, and use the substitute code below\n  // options: ClientOptions = {} as ClientOptions,\n  tunnelOrOptions: string | ClientOptions = {} as ClientOptions,\n): string {\n  // TODO (v8): Use this code instead\n  // const { tunnel, _metadata = {} } = options;\n  // return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, _metadata.sdk)}`;\n\n  const tunnel = typeof tunnelOrOptions === 'string' ? tunnelOrOptions : tunnelOrOptions.tunnel;\n  const sdkInfo =\n    typeof tunnelOrOptions === 'string' || !tunnelOrOptions._metadata ? undefined : tunnelOrOptions._metadata.sdk;\n\n  return tunnel ? tunnel : `${_getIngestEndpoint(dsn)}?${_encodedAuth(dsn, sdkInfo)}`;\n}\n\n/** Returns the url to the report dialog endpoint. */\nexport function getReportDialogEndpoint(\n  dsnLike: DsnLike,\n  dialogOptions: {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    [key: string]: any;\n    user?: { name?: string; email?: string };\n  },\n): string {\n  const dsn = makeDsn(dsnLike);\n  if (!dsn) {\n    return '';\n  }\n\n  const endpoint = `${getBaseApiEndpoint(dsn)}embed/error-page/`;\n\n  let encodedOptions = `dsn=${dsnToString(dsn)}`;\n  for (const key in dialogOptions) {\n    if (key === 'dsn') {\n      continue;\n    }\n\n    if (key === 'onClose') {\n      continue;\n    }\n\n    if (key === 'user') {\n      const user = dialogOptions.user;\n      if (!user) {\n        continue;\n      }\n      if (user.name) {\n        encodedOptions += `&name=${encodeURIComponent(user.name)}`;\n      }\n      if (user.email) {\n        encodedOptions += `&email=${encodeURIComponent(user.email)}`;\n      }\n    } else {\n      encodedOptions += `&${encodeURIComponent(key)}=${encodeURIComponent(dialogOptions[key] as string)}`;\n    }\n  }\n\n  return `${endpoint}?${encodedOptions}`;\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/ban-types */\nimport type { ConsoleLevel, HandlerDataConsole } from '@sentry/types';\n\nimport { CONSOLE_LEVELS, originalConsoleMethods } from '../logger';\nimport { fill } from '../object';\nimport { GLOBAL_OBJ } from '../worldwide';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers';\n\n/**\n * Add an instrumentation handler for when a console.xxx method is called.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addConsoleInstrumentationHandler(handler: (data: HandlerDataConsole) => void): void {\n  const type = 'console';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentConsole);\n}\n\nfunction instrumentConsole(): void {\n  if (!('console' in GLOBAL_OBJ)) {\n    return;\n  }\n\n  CONSOLE_LEVELS.forEach(function (level: ConsoleLevel): void {\n    if (!(level in GLOBAL_OBJ.console)) {\n      return;\n    }\n\n    fill(GLOBAL_OBJ.console, level, function (originalConsoleMethod: () => any): Function {\n      originalConsoleMethods[level] = originalConsoleMethod;\n\n      return function (...args: any[]): void {\n        const handlerData: HandlerDataConsole = { args, level };\n        triggerHandlers('console', handlerData);\n\n        const log = originalConsoleMethods[level];\n        log && log.apply(GLOBAL_OBJ.console, args);\n      };\n    });\n  });\n}\n","/* eslint-disable max-lines */\nimport type {\n  Breadcrumb,\n  BreadcrumbHint,\n  Client,\n  CustomSamplingContext,\n  Event,\n  EventHint,\n  Extra,\n  Extras,\n  Hub as HubInterface,\n  Integration,\n  IntegrationClass,\n  Primitive,\n  Session,\n  SessionContext,\n  Severity,\n  SeverityLevel,\n  Transaction,\n  TransactionContext,\n  User,\n} from '@sentry/types';\nimport {\n  GLOBAL_OBJ,\n  consoleSandbox,\n  dateTimestampInSeconds,\n  getGlobalSingleton,\n  isThenable,\n  logger,\n  uuid4,\n} from '@sentry/utils';\n\nimport { DEFAULT_ENVIRONMENT } from './constants';\nimport { DEBUG_BUILD } from './debug-build';\nimport { Scope } from './scope';\nimport { closeSession, makeSession, updateSession } from './session';\nimport { SDK_VERSION } from './version';\n\n/**\n * API compatibility version of this hub.\n *\n * WARNING: This number should only be increased when the global interface\n * changes and new methods are introduced.\n *\n * @hidden\n */\nexport const API_VERSION = parseFloat(SDK_VERSION);\n\n/**\n * Default maximum number of breadcrumbs added to an event. Can be overwritten\n * with {@link Options.maxBreadcrumbs}.\n */\nconst DEFAULT_BREADCRUMBS = 100;\n\nexport interface RunWithAsyncContextOptions {\n  /** Whether to reuse an existing async context if one exists. Defaults to false. */\n  reuseExisting?: boolean;\n}\n\n/**\n * @private Private API with no semver guarantees!\n *\n * Strategy used to track async context.\n */\nexport interface AsyncContextStrategy {\n  /**\n   * Gets the current async context. Returns undefined if there is no current async context.\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  getCurrentHub: () => Hub | undefined;\n  /**\n   * Runs the supplied callback in its own async context.\n   */\n  runWithAsyncContext<T>(callback: () => T, options: RunWithAsyncContextOptions): T;\n}\n\n/**\n * A layer in the process stack.\n * @hidden\n */\nexport interface Layer {\n  client?: Client;\n  scope: Scope;\n}\n\n/**\n * An object that contains a hub and maintains a scope stack.\n * @hidden\n */\nexport interface Carrier {\n  __SENTRY__?: {\n    // eslint-disable-next-line deprecation/deprecation\n    hub?: Hub;\n    acs?: AsyncContextStrategy;\n    /**\n     * Extra Hub properties injected by various SDKs\n     */\n    integrations?: Integration[];\n    extensions?: {\n      /** Extension methods for the hub, which are bound to the current Hub instance */\n      // eslint-disable-next-line @typescript-eslint/ban-types\n      [key: string]: Function;\n    };\n  };\n}\n\n/**\n * @deprecated The `Hub` class will be removed in version 8 of the SDK in favour of `Scope` and `Client` objects.\n *\n * If you previously used the `Hub` class directly, replace it with `Scope` and `Client` objects. More information:\n * - [Multiple Sentry Instances](https://docs.sentry.io/platforms/javascript/best-practices/multiple-sentry-instances/)\n * - [Browser Extensions](https://docs.sentry.io/platforms/javascript/best-practices/browser-extensions/)\n *\n * Some of our APIs are typed with the Hub class instead of the interface (e.g. `getCurrentHub`). Most of them are deprecated\n * themselves and will also be removed in version 8. More information:\n * - [Migration Guide](https://github.com/getsentry/sentry-javascript/blob/develop/MIGRATION.md#deprecate-hub)\n */\n// eslint-disable-next-line deprecation/deprecation\nexport class Hub implements HubInterface {\n  /** Is a {@link Layer}[] containing the client and scope */\n  private readonly _stack: Layer[];\n\n  /** Contains the last event id of a captured event.  */\n  private _lastEventId?: string;\n\n  private _isolationScope: Scope;\n\n  /**\n   * Creates a new instance of the hub, will push one {@link Layer} into the\n   * internal stack on creation.\n   *\n   * @param client bound to the hub.\n   * @param scope bound to the hub.\n   * @param version number, higher number means higher priority.\n   *\n   * @deprecated Instantiation of Hub objects is deprecated and the constructor will be removed in version 8 of the SDK.\n   *\n   * If you are currently using the Hub for multi-client use like so:\n   *\n   * ```\n   * // OLD\n   * const hub = new Hub();\n   * hub.bindClient(client);\n   * makeMain(hub)\n   * ```\n   *\n   * instead initialize the client as follows:\n   *\n   * ```\n   * // NEW\n   * Sentry.withIsolationScope(() => {\n   *    Sentry.setCurrentClient(client);\n   *    client.init();\n   * });\n   * ```\n   *\n   * If you are using the Hub to capture events like so:\n   *\n   * ```\n   * // OLD\n   * const client = new Client();\n   * const hub = new Hub(client);\n   * hub.captureException()\n   * ```\n   *\n   * instead capture isolated events as follows:\n   *\n   * ```\n   * // NEW\n   * const client = new Client();\n   * const scope = new Scope();\n   * scope.setClient(client);\n   * scope.captureException();\n   * ```\n   */\n  public constructor(\n    client?: Client,\n    scope?: Scope,\n    isolationScope?: Scope,\n    private readonly _version: number = API_VERSION,\n  ) {\n    let assignedScope;\n    if (!scope) {\n      assignedScope = new Scope();\n      assignedScope.setClient(client);\n    } else {\n      assignedScope = scope;\n    }\n\n    let assignedIsolationScope;\n    if (!isolationScope) {\n      assignedIsolationScope = new Scope();\n      assignedIsolationScope.setClient(client);\n    } else {\n      assignedIsolationScope = isolationScope;\n    }\n\n    this._stack = [{ scope: assignedScope }];\n\n    if (client) {\n      // eslint-disable-next-line deprecation/deprecation\n      this.bindClient(client);\n    }\n\n    this._isolationScope = assignedIsolationScope;\n  }\n\n  /**\n   * Checks if this hub's version is older than the given version.\n   *\n   * @param version A version number to compare to.\n   * @return True if the given version is newer; otherwise false.\n   *\n   * @deprecated This will be removed in v8.\n   */\n  public isOlderThan(version: number): boolean {\n    return this._version < version;\n  }\n\n  /**\n   * This binds the given client to the current scope.\n   * @param client An SDK client (client) instance.\n   *\n   * @deprecated Use `initAndBind()` directly, or `setCurrentClient()` and/or `client.init()` instead.\n   */\n  public bindClient(client?: Client): void {\n    // eslint-disable-next-line deprecation/deprecation\n    const top = this.getStackTop();\n    top.client = client;\n    top.scope.setClient(client);\n    // eslint-disable-next-line deprecation/deprecation\n    if (client && client.setupIntegrations) {\n      // eslint-disable-next-line deprecation/deprecation\n      client.setupIntegrations();\n    }\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Use `withScope` instead.\n   */\n  public pushScope(): Scope {\n    // We want to clone the content of prev scope\n    // eslint-disable-next-line deprecation/deprecation\n    const scope = this.getScope().clone();\n    // eslint-disable-next-line deprecation/deprecation\n    this.getStack().push({\n      // eslint-disable-next-line deprecation/deprecation\n      client: this.getClient(),\n      scope,\n    });\n    return scope;\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Use `withScope` instead.\n   */\n  public popScope(): boolean {\n    // eslint-disable-next-line deprecation/deprecation\n    if (this.getStack().length <= 1) return false;\n    // eslint-disable-next-line deprecation/deprecation\n    return !!this.getStack().pop();\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Use `Sentry.withScope()` instead.\n   */\n  public withScope<T>(callback: (scope: Scope) => T): T {\n    // eslint-disable-next-line deprecation/deprecation\n    const scope = this.pushScope();\n\n    let maybePromiseResult: T;\n    try {\n      maybePromiseResult = callback(scope);\n    } catch (e) {\n      // eslint-disable-next-line deprecation/deprecation\n      this.popScope();\n      throw e;\n    }\n\n    if (isThenable(maybePromiseResult)) {\n      // @ts-expect-error - isThenable returns the wrong type\n      return maybePromiseResult.then(\n        res => {\n          // eslint-disable-next-line deprecation/deprecation\n          this.popScope();\n          return res;\n        },\n        e => {\n          // eslint-disable-next-line deprecation/deprecation\n          this.popScope();\n          throw e;\n        },\n      );\n    }\n\n    // eslint-disable-next-line deprecation/deprecation\n    this.popScope();\n    return maybePromiseResult;\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Use `Sentry.getClient()` instead.\n   */\n  public getClient<C extends Client>(): C | undefined {\n    // eslint-disable-next-line deprecation/deprecation\n    return this.getStackTop().client as C;\n  }\n\n  /**\n   * Returns the scope of the top stack.\n   *\n   * @deprecated Use `Sentry.getCurrentScope()` instead.\n   */\n  public getScope(): Scope {\n    // eslint-disable-next-line deprecation/deprecation\n    return this.getStackTop().scope;\n  }\n\n  /**\n   * @deprecated Use `Sentry.getIsolationScope()` instead.\n   */\n  public getIsolationScope(): Scope {\n    return this._isolationScope;\n  }\n\n  /**\n   * Returns the scope stack for domains or the process.\n   * @deprecated This will be removed in v8.\n   */\n  public getStack(): Layer[] {\n    return this._stack;\n  }\n\n  /**\n   * Returns the topmost scope layer in the order domain > local > process.\n   * @deprecated This will be removed in v8.\n   */\n  public getStackTop(): Layer {\n    return this._stack[this._stack.length - 1];\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Use `Sentry.captureException()` instead.\n   */\n  public captureException(exception: unknown, hint?: EventHint): string {\n    const eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n    const syntheticException = new Error('Sentry syntheticException');\n    // eslint-disable-next-line deprecation/deprecation\n    this.getScope().captureException(exception, {\n      originalException: exception,\n      syntheticException,\n      ...hint,\n      event_id: eventId,\n    });\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Use  `Sentry.captureMessage()` instead.\n   */\n  public captureMessage(\n    message: string,\n    // eslint-disable-next-line deprecation/deprecation\n    level?: Severity | SeverityLevel,\n    hint?: EventHint,\n  ): string {\n    const eventId = (this._lastEventId = hint && hint.event_id ? hint.event_id : uuid4());\n    const syntheticException = new Error(message);\n    // eslint-disable-next-line deprecation/deprecation\n    this.getScope().captureMessage(message, level, {\n      originalException: message,\n      syntheticException,\n      ...hint,\n      event_id: eventId,\n    });\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Use `Sentry.captureEvent()` instead.\n   */\n  public captureEvent(event: Event, hint?: EventHint): string {\n    const eventId = hint && hint.event_id ? hint.event_id : uuid4();\n    if (!event.type) {\n      this._lastEventId = eventId;\n    }\n    // eslint-disable-next-line deprecation/deprecation\n    this.getScope().captureEvent(event, { ...hint, event_id: eventId });\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated This will be removed in v8.\n   */\n  public lastEventId(): string | undefined {\n    return this._lastEventId;\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Use `Sentry.addBreadcrumb()` instead.\n   */\n  public addBreadcrumb(breadcrumb: Breadcrumb, hint?: BreadcrumbHint): void {\n    // eslint-disable-next-line deprecation/deprecation\n    const { scope, client } = this.getStackTop();\n\n    if (!client) return;\n\n    const { beforeBreadcrumb = null, maxBreadcrumbs = DEFAULT_BREADCRUMBS } =\n      (client.getOptions && client.getOptions()) || {};\n\n    if (maxBreadcrumbs <= 0) return;\n\n    const timestamp = dateTimestampInSeconds();\n    const mergedBreadcrumb = { timestamp, ...breadcrumb };\n    const finalBreadcrumb = beforeBreadcrumb\n      ? (consoleSandbox(() => beforeBreadcrumb(mergedBreadcrumb, hint)) as Breadcrumb | null)\n      : mergedBreadcrumb;\n\n    if (finalBreadcrumb === null) return;\n\n    if (client.emit) {\n      client.emit('beforeAddBreadcrumb', finalBreadcrumb, hint);\n    }\n\n    // TODO(v8): I know this comment doesn't make much sense because the hub will be deprecated but I still wanted to\n    // write it down. In theory, we would have to add the breadcrumbs to the isolation scope here, however, that would\n    // duplicate all of the breadcrumbs. There was the possibility of adding breadcrumbs to both, the isolation scope\n    // and the normal scope, and deduplicating it down the line in the event processing pipeline. However, that would\n    // have been very fragile, because the breadcrumb objects would have needed to keep their identity all throughout\n    // the event processing pipeline.\n    // In the new implementation, the top level `Sentry.addBreadcrumb()` should ONLY write to the isolation scope.\n\n    scope.addBreadcrumb(finalBreadcrumb, maxBreadcrumbs);\n  }\n\n  /**\n   * @inheritDoc\n   * @deprecated Use `Sentry.setUser()` instead.\n   */\n  public setUser(user: User | null): void {\n    // TODO(v8): The top level `Sentry.setUser()` function should write ONLY to the isolation scope.\n    // eslint-disable-next-line deprecation/deprecation\n    this.getScope().setUser(user);\n    // eslint-disable-next-line deprecation/deprecation\n    this.getIsolationScope().setUser(user);\n  }\n\n  /**\n   * @inheritDoc\n   * @deprecated Use `Sentry.setTags()` instead.\n   */\n  public setTags(tags: { [key: string]: Primitive }): void {\n    // TODO(v8): The top level `Sentry.setTags()` function should write ONLY to the isolation scope.\n    // eslint-disable-next-line deprecation/deprecation\n    this.getScope().setTags(tags);\n    // eslint-disable-next-line deprecation/deprecation\n    this.getIsolationScope().setTags(tags);\n  }\n\n  /**\n   * @inheritDoc\n   * @deprecated Use `Sentry.setExtras()` instead.\n   */\n  public setExtras(extras: Extras): void {\n    // TODO(v8): The top level `Sentry.setExtras()` function should write ONLY to the isolation scope.\n    // eslint-disable-next-line deprecation/deprecation\n    this.getScope().setExtras(extras);\n    // eslint-disable-next-line deprecation/deprecation\n    this.getIsolationScope().setExtras(extras);\n  }\n\n  /**\n   * @inheritDoc\n   * @deprecated Use `Sentry.setTag()` instead.\n   */\n  public setTag(key: string, value: Primitive): void {\n    // TODO(v8): The top level `Sentry.setTag()` function should write ONLY to the isolation scope.\n    // eslint-disable-next-line deprecation/deprecation\n    this.getScope().setTag(key, value);\n    // eslint-disable-next-line deprecation/deprecation\n    this.getIsolationScope().setTag(key, value);\n  }\n\n  /**\n   * @inheritDoc\n   * @deprecated Use `Sentry.setExtra()` instead.\n   */\n  public setExtra(key: string, extra: Extra): void {\n    // TODO(v8): The top level `Sentry.setExtra()` function should write ONLY to the isolation scope.\n    // eslint-disable-next-line deprecation/deprecation\n    this.getScope().setExtra(key, extra);\n    // eslint-disable-next-line deprecation/deprecation\n    this.getIsolationScope().setExtra(key, extra);\n  }\n\n  /**\n   * @inheritDoc\n   * @deprecated Use `Sentry.setContext()` instead.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public setContext(name: string, context: { [key: string]: any } | null): void {\n    // TODO(v8): The top level `Sentry.setContext()` function should write ONLY to the isolation scope.\n    // eslint-disable-next-line deprecation/deprecation\n    this.getScope().setContext(name, context);\n    // eslint-disable-next-line deprecation/deprecation\n    this.getIsolationScope().setContext(name, context);\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Use `getScope()` directly.\n   */\n  public configureScope(callback: (scope: Scope) => void): void {\n    // eslint-disable-next-line deprecation/deprecation\n    const { scope, client } = this.getStackTop();\n    if (client) {\n      callback(scope);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  public run(callback: (hub: Hub) => void): void {\n    // eslint-disable-next-line deprecation/deprecation\n    const oldHub = makeMain(this);\n    try {\n      callback(this);\n    } finally {\n      // eslint-disable-next-line deprecation/deprecation\n      makeMain(oldHub);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   * @deprecated Use `Sentry.getClient().getIntegrationByName()` instead.\n   */\n  public getIntegration<T extends Integration>(integration: IntegrationClass<T>): T | null {\n    // eslint-disable-next-line deprecation/deprecation\n    const client = this.getClient();\n    if (!client) return null;\n    try {\n      // eslint-disable-next-line deprecation/deprecation\n      return client.getIntegration(integration);\n    } catch (_oO) {\n      DEBUG_BUILD && logger.warn(`Cannot retrieve integration ${integration.id} from the current Hub`);\n      return null;\n    }\n  }\n\n  /**\n   * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.\n   *\n   * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a\n   * new child span within the transaction or any span, call the respective `.startChild()` method.\n   *\n   * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.\n   *\n   * The transaction must be finished with a call to its `.end()` method, at which point the transaction with all its\n   * finished child spans will be sent to Sentry.\n   *\n   * @param context Properties of the new `Transaction`.\n   * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent\n   * default values). See {@link Options.tracesSampler}.\n   *\n   * @returns The transaction which was just started\n   *\n   * @deprecated Use `startSpan()`, `startSpanManual()` or `startInactiveSpan()` instead.\n   */\n  public startTransaction(context: TransactionContext, customSamplingContext?: CustomSamplingContext): Transaction {\n    const result = this._callExtensionMethod<Transaction>('startTransaction', context, customSamplingContext);\n\n    if (DEBUG_BUILD && !result) {\n      // eslint-disable-next-line deprecation/deprecation\n      const client = this.getClient();\n      if (!client) {\n        logger.warn(\n          \"Tracing extension 'startTransaction' is missing. You should 'init' the SDK before calling 'startTransaction'\",\n        );\n      } else {\n        logger.warn(`Tracing extension 'startTransaction' has not been added. Call 'addTracingExtensions' before calling 'init':\nSentry.addTracingExtensions();\nSentry.init({...});\n`);\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * @inheritDoc\n   * @deprecated Use `spanToTraceHeader()` instead.\n   */\n  public traceHeaders(): { [key: string]: string } {\n    return this._callExtensionMethod<{ [key: string]: string }>('traceHeaders');\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Use top level `captureSession` instead.\n   */\n  public captureSession(endSession: boolean = false): void {\n    // both send the update and pull the session from the scope\n    if (endSession) {\n      // eslint-disable-next-line deprecation/deprecation\n      return this.endSession();\n    }\n\n    // only send the update\n    this._sendSessionUpdate();\n  }\n\n  /**\n   * @inheritDoc\n   * @deprecated Use top level `endSession` instead.\n   */\n  public endSession(): void {\n    // eslint-disable-next-line deprecation/deprecation\n    const layer = this.getStackTop();\n    const scope = layer.scope;\n    const session = scope.getSession();\n    if (session) {\n      closeSession(session);\n    }\n    this._sendSessionUpdate();\n\n    // the session is over; take it off of the scope\n    scope.setSession();\n  }\n\n  /**\n   * @inheritDoc\n   * @deprecated Use top level `startSession` instead.\n   */\n  public startSession(context?: SessionContext): Session {\n    // eslint-disable-next-line deprecation/deprecation\n    const { scope, client } = this.getStackTop();\n    const { release, environment = DEFAULT_ENVIRONMENT } = (client && client.getOptions()) || {};\n\n    // Will fetch userAgent if called from browser sdk\n    const { userAgent } = GLOBAL_OBJ.navigator || {};\n\n    const session = makeSession({\n      release,\n      environment,\n      user: scope.getUser(),\n      ...(userAgent && { userAgent }),\n      ...context,\n    });\n\n    // End existing session if there's one\n    const currentSession = scope.getSession && scope.getSession();\n    if (currentSession && currentSession.status === 'ok') {\n      updateSession(currentSession, { status: 'exited' });\n    }\n    // eslint-disable-next-line deprecation/deprecation\n    this.endSession();\n\n    // Afterwards we set the new session on the scope\n    scope.setSession(session);\n\n    return session;\n  }\n\n  /**\n   * Returns if default PII should be sent to Sentry and propagated in ourgoing requests\n   * when Tracing is used.\n   *\n   * @deprecated Use top-level `getClient().getOptions().sendDefaultPii` instead. This function\n   * only unnecessarily increased API surface but only wrapped accessing the option.\n   */\n  public shouldSendDefaultPii(): boolean {\n    // eslint-disable-next-line deprecation/deprecation\n    const client = this.getClient();\n    const options = client && client.getOptions();\n    return Boolean(options && options.sendDefaultPii);\n  }\n\n  /**\n   * Sends the current Session on the scope\n   */\n  private _sendSessionUpdate(): void {\n    // eslint-disable-next-line deprecation/deprecation\n    const { scope, client } = this.getStackTop();\n\n    const session = scope.getSession();\n    if (session && client && client.captureSession) {\n      client.captureSession(session);\n    }\n  }\n\n  /**\n   * Calls global extension method and binding current instance to the function call\n   */\n  // @ts-expect-error Function lacks ending return statement and return type does not include 'undefined'. ts(2366)\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private _callExtensionMethod<T>(method: string, ...args: any[]): T {\n    const carrier = getMainCarrier();\n    const sentry = carrier.__SENTRY__;\n    if (sentry && sentry.extensions && typeof sentry.extensions[method] === 'function') {\n      return sentry.extensions[method].apply(this, args);\n    }\n    DEBUG_BUILD && logger.warn(`Extension method ${method} couldn't be found, doing nothing.`);\n  }\n}\n\n/**\n * Returns the global shim registry.\n *\n * FIXME: This function is problematic, because despite always returning a valid Carrier,\n * it has an optional `__SENTRY__` property, which then in turn requires us to always perform an unnecessary check\n * at the call-site. We always access the carrier through this function, so we can guarantee that `__SENTRY__` is there.\n **/\nexport function getMainCarrier(): Carrier {\n  GLOBAL_OBJ.__SENTRY__ = GLOBAL_OBJ.__SENTRY__ || {\n    extensions: {},\n    hub: undefined,\n  };\n  return GLOBAL_OBJ;\n}\n\n/**\n * Replaces the current main hub with the passed one on the global object\n *\n * @returns The old replaced hub\n *\n * @deprecated Use `setCurrentClient()` instead.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport function makeMain(hub: Hub): Hub {\n  const registry = getMainCarrier();\n  const oldHub = getHubFromCarrier(registry);\n  setHubOnCarrier(registry, hub);\n  return oldHub;\n}\n\n/**\n * Returns the default hub instance.\n *\n * If a hub is already registered in the global carrier but this module\n * contains a more recent version, it replaces the registered version.\n * Otherwise, the currently registered hub will be returned.\n *\n * @deprecated Use the respective replacement method directly instead.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport function getCurrentHub(): Hub {\n  // Get main carrier (global for every environment)\n  const registry = getMainCarrier();\n\n  if (registry.__SENTRY__ && registry.__SENTRY__.acs) {\n    const hub = registry.__SENTRY__.acs.getCurrentHub();\n\n    if (hub) {\n      return hub;\n    }\n  }\n\n  // Return hub that lives on a global object\n  return getGlobalHub(registry);\n}\n\n/**\n * Get the currently active isolation scope.\n * The isolation scope is active for the current exection context,\n * meaning that it will remain stable for the same Hub.\n */\nexport function getIsolationScope(): Scope {\n  // eslint-disable-next-line deprecation/deprecation\n  return getCurrentHub().getIsolationScope();\n}\n\n// eslint-disable-next-line deprecation/deprecation\nfunction getGlobalHub(registry: Carrier = getMainCarrier()): Hub {\n  // If there's no hub, or its an old API, assign a new one\n\n  if (\n    !hasHubOnCarrier(registry) ||\n    // eslint-disable-next-line deprecation/deprecation\n    getHubFromCarrier(registry).isOlderThan(API_VERSION)\n  ) {\n    // eslint-disable-next-line deprecation/deprecation\n    setHubOnCarrier(registry, new Hub());\n  }\n\n  // Return hub that lives on a global object\n  return getHubFromCarrier(registry);\n}\n\n/**\n * @private Private API with no semver guarantees!\n *\n * If the carrier does not contain a hub, a new hub is created with the global hub client and scope.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport function ensureHubOnCarrier(carrier: Carrier, parent: Hub = getGlobalHub()): void {\n  // If there's no hub on current domain, or it's an old API, assign a new one\n  if (\n    !hasHubOnCarrier(carrier) ||\n    // eslint-disable-next-line deprecation/deprecation\n    getHubFromCarrier(carrier).isOlderThan(API_VERSION)\n  ) {\n    // eslint-disable-next-line deprecation/deprecation\n    const client = parent.getClient();\n    // eslint-disable-next-line deprecation/deprecation\n    const scope = parent.getScope();\n    // eslint-disable-next-line deprecation/deprecation\n    const isolationScope = parent.getIsolationScope();\n    // eslint-disable-next-line deprecation/deprecation\n    setHubOnCarrier(carrier, new Hub(client, scope.clone(), isolationScope.clone()));\n  }\n}\n\n/**\n * @private Private API with no semver guarantees!\n *\n * Sets the global async context strategy\n */\nexport function setAsyncContextStrategy(strategy: AsyncContextStrategy | undefined): void {\n  // Get main carrier (global for every environment)\n  const registry = getMainCarrier();\n  registry.__SENTRY__ = registry.__SENTRY__ || {};\n  registry.__SENTRY__.acs = strategy;\n}\n\n/**\n * Runs the supplied callback in its own async context. Async Context strategies are defined per SDK.\n *\n * @param callback The callback to run in its own async context\n * @param options Options to pass to the async context strategy\n * @returns The result of the callback\n */\nexport function runWithAsyncContext<T>(callback: () => T, options: RunWithAsyncContextOptions = {}): T {\n  const registry = getMainCarrier();\n\n  if (registry.__SENTRY__ && registry.__SENTRY__.acs) {\n    return registry.__SENTRY__.acs.runWithAsyncContext(callback, options);\n  }\n\n  // if there was no strategy, fallback to just calling the callback\n  return callback();\n}\n\n/**\n * This will tell whether a carrier has a hub on it or not\n * @param carrier object\n */\nfunction hasHubOnCarrier(carrier: Carrier): boolean {\n  return !!(carrier && carrier.__SENTRY__ && carrier.__SENTRY__.hub);\n}\n\n/**\n * This will create a new {@link Hub} and add to the passed object on\n * __SENTRY__.hub.\n * @param carrier object\n * @hidden\n */\n// eslint-disable-next-line deprecation/deprecation\nexport function getHubFromCarrier(carrier: Carrier): Hub {\n  // eslint-disable-next-line deprecation/deprecation\n  return getGlobalSingleton<Hub>('hub', () => new Hub(), carrier);\n}\n\n/**\n * This will set passed {@link Hub} on the passed object's __SENTRY__.hub attribute\n * @param carrier object\n * @param hub Hub\n * @returns A boolean indicating success or failure\n */\n// eslint-disable-next-line deprecation/deprecation\nexport function setHubOnCarrier(carrier: Carrier, hub: Hub): boolean {\n  if (!carrier) return false;\n  const __SENTRY__ = (carrier.__SENTRY__ = carrier.__SENTRY__ || {});\n  __SENTRY__.hub = hub;\n  return true;\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\nimport type { Metric } from '../../types';\nimport { observe } from '../observe';\n\ndeclare global {\n  interface Performance {\n    interactionCount: number;\n  }\n}\n\nlet interactionCountEstimate = 0;\nlet minKnownInteractionId = Infinity;\nlet maxKnownInteractionId = 0;\n\nconst updateEstimate = (entries: Metric['entries']): void => {\n  (entries as PerformanceEventTiming[]).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: PerformanceObserver | undefined;\n\n/**\n * Returns the `interactionCount` value using the native API (if available)\n * or the polyfill estimate in this module.\n */\nexport const getInteractionCount = (): number => {\n  return po ? interactionCountEstimate : performance.interactionCount || 0;\n};\n\n/**\n * Feature detects native support or initializes the polyfill if needed.\n */\nexport const initInteractionCountPolyfill = (): void => {\n  if ('interactionCount' in performance || po) return;\n\n  po = observe('event', updateEstimate, {\n    type: 'event',\n    buffered: true,\n    durationThreshold: 0,\n  } as PerformanceObserverInit);\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\nimport type { Metric, ReportCallback } from '../types';\n\nexport const bindReporter = (\n  callback: ReportCallback,\n  metric: Metric,\n  reportAllChanges?: boolean,\n): ((forceReport?: boolean) => void) => {\n  let prevValue: number;\n  let delta: number;\n  return (forceReport?: boolean) => {\n    if (metric.value >= 0) {\n      if (forceReport || reportAllChanges) {\n        delta = metric.value - (prevValue || 0);\n\n        // Report the metric if there's a non-zero delta or if no previous\n        // value exists (which can happen in the case of the document becoming\n        // hidden when the metric value is 0).\n        // See: https://github.com/GoogleChrome/web-vitals/issues/14\n        if (delta || prevValue === undefined) {\n          prevValue = metric.value;\n          metric.delta = delta;\n          callback(metric);\n        }\n      }\n    }\n  };\n};\n","/*\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\nimport { getNavigationEntry } from './getNavigationEntry';\n\nexport const getActivationStart = (): number => {\n  const navEntry = getNavigationEntry();\n  return (navEntry && navEntry.activationStart) || 0;\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\nimport { WINDOW } from '../../types';\nimport type { Metric } from '../types';\nimport { generateUniqueID } from './generateUniqueID';\nimport { getActivationStart } from './getActivationStart';\nimport { getNavigationEntry } from './getNavigationEntry';\n\nexport const initMetric = (name: Metric['name'], value?: number): Metric => {\n  const navEntry = getNavigationEntry();\n  let navigationType: Metric['navigationType'] = 'navigate';\n\n  if (navEntry) {\n    if ((WINDOW.document && WINDOW.document.prerendering) || getActivationStart() > 0) {\n      navigationType = 'prerender';\n    } else {\n      navigationType = navEntry.type.replace(/_/g, '-') as Metric['navigationType'];\n    }\n  }\n\n  return {\n    name,\n    value: typeof value === 'undefined' ? -1 : value,\n    rating: 'good', // Will be updated if the value changes.\n    delta: 0,\n    entries: [],\n    id: generateUniqueID(),\n    navigationType,\n  };\n};\n","/*\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 */\nexport const generateUniqueID = (): string => {\n  return `v3-${Date.now()}-${Math.floor(Math.random() * (9e12 - 1)) + 1e12}`;\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\nimport type { FirstInputPolyfillEntry, NavigationTimingPolyfillEntry, PerformancePaintTiming } from '../types';\n\nexport interface PerformanceEntryHandler {\n  (entry: PerformanceEntry): void;\n}\n\ninterface PerformanceEntryMap {\n  event: PerformanceEventTiming[];\n  paint: PerformancePaintTiming[];\n  'layout-shift': LayoutShift[];\n  'largest-contentful-paint': LargestContentfulPaint[];\n  'first-input': PerformanceEventTiming[] | FirstInputPolyfillEntry[];\n  navigation: PerformanceNavigationTiming[] | NavigationTimingPolyfillEntry[];\n  resource: PerformanceResourceTiming[];\n  longtask: PerformanceEntry[];\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 */\nexport const observe = <K extends keyof PerformanceEntryMap>(\n  type: K,\n  callback: (entries: PerformanceEntryMap[K]) => void,\n  opts?: PerformanceObserverInit,\n): PerformanceObserver | undefined => {\n  try {\n    if (PerformanceObserver.supportedEntryTypes.includes(type)) {\n      const po = new PerformanceObserver(list => {\n        callback(list.getEntries() as PerformanceEntryMap[K]);\n      });\n      po.observe(\n        Object.assign(\n          {\n            type,\n            buffered: true,\n          },\n          opts || {},\n        ) as PerformanceObserverInit,\n      );\n      return po;\n    }\n  } catch (e) {\n    // Do nothing.\n  }\n  return;\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\nimport { bindReporter } from './lib/bindReporter';\nimport { initMetric } from './lib/initMetric';\nimport { observe } from './lib/observe';\nimport { onHidden } from './lib/onHidden';\nimport type { CLSMetric, ReportCallback, StopListening } from './types';\n\n/**\n * Calculates the [CLS](https://web.dev/cls/) value for the current page and\n * calls the `callback` function once the value is ready to be reported, along\n * with all `layout-shift` performance entries that were used in the metric\n * value calculation. The reported value is a `double` (corresponding to a\n * [layout shift score](https://web.dev/cls/#layout-shift-score)).\n *\n * If the `reportAllChanges` configuration option is set to `true`, the\n * `callback` function will be called as soon as the value is initially\n * determined as well as any time the value changes throughout the page\n * lifespan.\n *\n * _**Important:** CLS should be continually monitored for changes throughout\n * the entire lifespan of a page—including if the user returns to the page after\n * it's been hidden/backgrounded. However, since browsers often [will not fire\n * additional callbacks once the user has backgrounded a\n * page](https://developer.chrome.com/blog/page-lifecycle-api/#advice-hidden),\n * `callback` is always called when the page's visibility state changes to\n * hidden. As a result, the `callback` function might be called multiple times\n * during the same page load._\n */\nexport const onCLS = (\n  onReport: ReportCallback,\n  options: { reportAllChanges?: boolean } = {},\n): StopListening | undefined => {\n  const metric = initMetric('CLS', 0);\n  let report: ReturnType<typeof bindReporter>;\n\n  let sessionValue = 0;\n  let sessionEntries: PerformanceEntry[] = [];\n\n  // const handleEntries = (entries: Metric['entries']) => {\n  const handleEntries = (entries: LayoutShift[]): void => {\n    entries.forEach(entry => {\n      // Only count layout shifts without recent user input.\n      if (!entry.hadRecentInput) {\n        const firstSessionEntry = sessionEntries[0];\n        const lastSessionEntry = sessionEntries[sessionEntries.length - 1];\n\n        // If the entry occurred less than 1 second after the previous entry and\n        // less than 5 seconds after the first entry in the session, include the\n        // entry in the current session. Otherwise, start a new session.\n        if (\n          sessionValue &&\n          sessionEntries.length !== 0 &&\n          entry.startTime - lastSessionEntry.startTime < 1000 &&\n          entry.startTime - firstSessionEntry.startTime < 5000\n        ) {\n          sessionValue += entry.value;\n          sessionEntries.push(entry);\n        } else {\n          sessionValue = entry.value;\n          sessionEntries = [entry];\n        }\n\n        // If the current session value is larger than the current CLS value,\n        // update CLS and the entries contributing to it.\n        if (sessionValue > metric.value) {\n          metric.value = sessionValue;\n          metric.entries = sessionEntries;\n          if (report) {\n            report();\n          }\n        }\n      }\n    });\n  };\n\n  const po = observe('layout-shift', handleEntries);\n  if (po) {\n    report = bindReporter(onReport, metric, options.reportAllChanges);\n\n    const stopListening = (): void => {\n      handleEntries(po.takeRecords() as CLSMetric['entries']);\n      report(true);\n    };\n\n    onHidden(stopListening);\n\n    return stopListening;\n  }\n\n  return;\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\nimport { bindReporter } from './lib/bindReporter';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher';\nimport { initMetric } from './lib/initMetric';\nimport { observe } from './lib/observe';\nimport { onHidden } from './lib/onHidden';\nimport type { FIDMetric, PerformanceEventTiming, ReportCallback } from './types';\n\n/**\n * Calculates the [FID](https://web.dev/fid/) value for the current page and\n * calls the `callback` function once the value is ready, along with the\n * relevant `first-input` performance entry used to determine the value. The\n * reported value is a `DOMHighResTimeStamp`.\n *\n * _**Important:** since FID is only reported after the user interacts with the\n * page, it's possible that it will not be reported for some page loads._\n */\nexport const onFID = (onReport: ReportCallback): void => {\n  const visibilityWatcher = getVisibilityWatcher();\n  const metric = initMetric('FID');\n  // eslint-disable-next-line prefer-const\n  let report: ReturnType<typeof bindReporter>;\n\n  const handleEntry = (entry: PerformanceEventTiming): void => {\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: FIDMetric['entries']): void => {\n    (entries as PerformanceEventTiming[]).forEach(handleEntry);\n  };\n\n  const po = observe('first-input', handleEntries);\n  report = bindReporter(onReport, metric);\n\n  if (po) {\n    onHidden(() => {\n      handleEntries(po.takeRecords() as FIDMetric['entries']);\n      po.disconnect();\n    }, true);\n  }\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\nimport { bindReporter } from './lib/bindReporter';\nimport { initMetric } from './lib/initMetric';\nimport { observe } from './lib/observe';\nimport { onHidden } from './lib/onHidden';\nimport { getInteractionCount, initInteractionCountPolyfill } from './lib/polyfills/interactionCountPolyfill';\nimport type { ReportCallback, ReportOpts } from './types';\nimport type { INPMetric } from './types/inp';\n\ninterface Interaction {\n  id: number;\n  latency: number;\n  entries: PerformanceEventTiming[];\n}\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 = (): number => {\n  return getInteractionCount();\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// A list of longest interactions on the page (by latency) sorted so the\n// longest one is first. The list is as most MAX_INTERACTIONS_TO_CONSIDER long.\nconst longestInteractionList: Interaction[] = [];\n\n// A mapping of longest interactions by their interaction ID.\n// This is used for faster lookup.\nconst longestInteractionMap: { [interactionId: string]: Interaction } = {};\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 processEntry = (entry: PerformanceEventTiming): void => {\n  // The least-long of the 10 longest interactions.\n  const minLongestInteraction = longestInteractionList[longestInteractionList.length - 1];\n\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  const existingInteraction = longestInteractionMap[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    entry.duration > minLongestInteraction.latency\n  ) {\n    // If the interaction already exists, update it. Otherwise create one.\n    if (existingInteraction) {\n      existingInteraction.entries.push(entry);\n      existingInteraction.latency = Math.max(existingInteraction.latency, entry.duration);\n    } else {\n      const interaction = {\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        id: entry.interactionId!,\n        latency: entry.duration,\n        entries: [entry],\n      };\n      longestInteractionMap[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    longestInteractionList.splice(MAX_INTERACTIONS_TO_CONSIDER).forEach(i => {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete longestInteractionMap[i.id];\n    });\n  }\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 = (): Interaction => {\n  const candidateInteractionIndex = Math.min(\n    longestInteractionList.length - 1,\n    Math.floor(getInteractionCountForNavigation() / 50),\n  );\n\n  return longestInteractionList[candidateInteractionIndex];\n};\n\n/**\n * Calculates the [INP](https://web.dev/responsiveness/) 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/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 */\nexport const onINP = (onReport: ReportCallback, opts?: ReportOpts): void => {\n  // Set defaults\n  // eslint-disable-next-line no-param-reassign\n  opts = opts || {};\n\n  // https://web.dev/inp/#what's-a-%22good%22-inp-value\n  // const thresholds = [200, 500];\n\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: ReturnType<typeof bindReporter>;\n\n  const handleEntries = (entries: INPMetric['entries']): void => {\n    entries.forEach(entry => {\n      if (entry.interactionId) {\n        processEntry(entry);\n      }\n\n      // Entries of type `first-input` don't currently have an `interactionId`,\n      // so to consider them in INP we have to first check that an existing\n      // entry doesn't match the `duration` and `startTime`.\n      // Note that this logic assumes that `event` entries are dispatched\n      // before `first-input` entries. This is true in Chrome but it is not\n      // true in Firefox; however, Firefox doesn't support interactionId, so\n      // it's not an issue at the moment.\n      // TODO(philipwalton): remove once crbug.com/1325826 is fixed.\n      if (entry.entryType === 'first-input') {\n        const noMatchingEntry = !longestInteractionList.some(interaction => {\n          return interaction.entries.some(prevEntry => {\n            return entry.duration === prevEntry.duration && entry.startTime === prevEntry.startTime;\n          });\n        });\n        if (noMatchingEntry) {\n          processEntry(entry);\n        }\n      }\n    });\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  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 || 40,\n  } as PerformanceObserverInit);\n\n  report = bindReporter(onReport, metric, 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() as INPMetric['entries']);\n\n      // If the interaction count shows that there were interactions but\n      // none were captured by the PerformanceObserver, report a latency of 0.\n      if (metric.value < 0 && getInteractionCountForNavigation() > 0) {\n        metric.value = 0;\n        metric.entries = [];\n      }\n\n      report(true);\n    });\n  }\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\nimport { WINDOW } from '../types';\nimport { bindReporter } from './lib/bindReporter';\nimport { getActivationStart } from './lib/getActivationStart';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher';\nimport { initMetric } from './lib/initMetric';\nimport { observe } from './lib/observe';\nimport { onHidden } from './lib/onHidden';\nimport type { LCPMetric, ReportCallback, StopListening } from './types';\n\nconst reportedMetricIDs: Record<string, boolean> = {};\n\n/**\n * Calculates the [LCP](https://web.dev/lcp/) value for the current page and\n * calls the `callback` function once the value is ready (along with the\n * relevant `largest-contentful-paint` performance entry used to determine the\n * value). The reported value is a `DOMHighResTimeStamp`.\n */\nexport const onLCP = (onReport: ReportCallback): StopListening | undefined => {\n  const visibilityWatcher = getVisibilityWatcher();\n  const metric = initMetric('LCP');\n  let report: ReturnType<typeof bindReporter>;\n\n  const handleEntries = (entries: LCPMetric['entries']): void => {\n    const lastEntry = entries[entries.length - 1] as LargestContentfulPaint;\n    if (lastEntry) {\n      // The startTime attribute returns the value of the renderTime if it is\n      // not 0, and the value of the loadTime otherwise. The activationStart\n      // reference is used because LCP should be relative to page activation\n      // rather than navigation start if the page was prerendered.\n      const value = Math.max(lastEntry.startTime - getActivationStart(), 0);\n\n      // Only report if the page wasn't hidden prior to LCP.\n      if (value < visibilityWatcher.firstHiddenTime) {\n        metric.value = value;\n        metric.entries = [lastEntry];\n        report();\n      }\n    }\n  };\n\n  const po = observe('largest-contentful-paint', handleEntries);\n\n  if (po) {\n    report = bindReporter(onReport, metric);\n\n    const stopListening = (): void => {\n      if (!reportedMetricIDs[metric.id]) {\n        handleEntries(po.takeRecords() as LCPMetric['entries']);\n        po.disconnect();\n        reportedMetricIDs[metric.id] = true;\n        report(true);\n      }\n    };\n\n    // Stop listening after input. Note: while scrolling is an input that\n    // stop LCP observation, it's unreliable since it can be programmatically\n    // generated. See: https://github.com/GoogleChrome/web-vitals/issues/75\n    ['keydown', 'click'].forEach(type => {\n      if (WINDOW.document) {\n        addEventListener(type, stopListening, { once: true, capture: true });\n      }\n    });\n\n    onHidden(stopListening, true);\n\n    return stopListening;\n  }\n\n  return;\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\nimport { WINDOW } from '../types';\nimport { bindReporter } from './lib/bindReporter';\nimport { getActivationStart } from './lib/getActivationStart';\nimport { getNavigationEntry } from './lib/getNavigationEntry';\nimport { initMetric } from './lib/initMetric';\nimport type { ReportCallback, ReportOpts } from './types';\nimport type { TTFBMetric } from './types/ttfb';\n\n/**\n * Runs in the next task after the page is done loading and/or prerendering.\n * @param callback\n */\nconst whenReady = (callback: () => void): void => {\n  if (!WINDOW.document) {\n    return;\n  }\n\n  if (WINDOW.document.prerendering) {\n    addEventListener('prerenderingchange', () => whenReady(callback), true);\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/time-to-first-byte/) 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 */\nexport const onTTFB = (onReport: ReportCallback, opts?: ReportOpts): void => {\n  // Set defaults\n  // eslint-disable-next-line no-param-reassign\n  opts = opts || {};\n\n  // https://web.dev/ttfb/#what-is-a-good-ttfb-score\n  // const thresholds = [800, 1800];\n\n  const metric = initMetric('TTFB');\n  const report = bindReporter(onReport, metric, opts.reportAllChanges);\n\n  whenReady(() => {\n    const navEntry = getNavigationEntry() as TTFBMetric['entries'][number];\n\n    if (navEntry) {\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(navEntry.responseStart - getActivationStart(), 0);\n\n      // In some cases the value reported is negative or is larger\n      // 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      if (metric.value < 0 || metric.value > performance.now()) return;\n\n      metric.entries = [navEntry];\n\n      report(true);\n    }\n  });\n};\n","import { getFunctionName, logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../common/debug-build';\nimport { onCLS } from './web-vitals/getCLS';\nimport { onFID } from './web-vitals/getFID';\nimport { onINP } from './web-vitals/getINP';\nimport { onLCP } from './web-vitals/getLCP';\nimport { observe } from './web-vitals/lib/observe';\nimport { onTTFB } from './web-vitals/onTTFB';\n\ntype InstrumentHandlerTypePerformanceObserver =\n  | 'longtask'\n  | 'event'\n  | 'navigation'\n  | 'paint'\n  | 'resource'\n  | 'first-input';\n\ntype InstrumentHandlerTypeMetric = 'cls' | 'lcp' | 'fid' | 'ttfb' | 'inp';\n\n// We provide this here manually instead of relying on a global, as this is not available in non-browser environements\n// And we do not want to expose such types\ninterface PerformanceEntry {\n  readonly duration: number;\n  readonly entryType: string;\n  readonly name: string;\n  readonly startTime: number;\n  toJSON(): Record<string, unknown>;\n}\ninterface PerformanceEventTiming extends PerformanceEntry {\n  processingStart: number;\n  processingEnd: number;\n  duration: number;\n  cancelable?: boolean;\n  target?: unknown | null;\n  interactionId?: number;\n}\n\ninterface Metric {\n  /**\n   * The name of the metric (in acronym form).\n   */\n  name: 'CLS' | 'FCP' | 'FID' | 'INP' | 'LCP' | 'TTFB';\n\n  /**\n   * The current value of the metric.\n   */\n  value: number;\n\n  /**\n   * The rating as to whether the metric value is within the \"good\",\n   * \"needs improvement\", or \"poor\" thresholds of the metric.\n   */\n  rating: 'good' | 'needs-improvement' | 'poor';\n\n  /**\n   * The delta between the current value and the last-reported value.\n   * On the first report, `delta` and `value` will always be the same.\n   */\n  delta: number;\n\n  /**\n   * A unique ID representing this particular metric instance. This ID can\n   * be used by an analytics tool to dedupe multiple values sent for the same\n   * metric instance, or to group multiple deltas together and calculate a\n   * total. It can also be used to differentiate multiple different metric\n   * instances sent from the same page, which can happen if the page is\n   * restored from the back/forward cache (in that case new metrics object\n   * get created).\n   */\n  id: string;\n\n  /**\n   * Any performance entries relevant to the metric value calculation.\n   * The array may also be empty if the metric value was not based on any\n   * entries (e.g. a CLS value of 0 given no layout shifts).\n   */\n  entries: PerformanceEntry[];\n\n  /**\n   * The type of navigation\n   *\n   * Navigation Timing API (or `undefined` if the browser doesn't\n   * support that API). For pages that are restored from the bfcache, this\n   * value will be 'back-forward-cache'.\n   */\n  navigationType: 'navigate' | 'reload' | 'back-forward' | 'back-forward-cache' | 'prerender';\n}\n\ntype InstrumentHandlerType = InstrumentHandlerTypeMetric | InstrumentHandlerTypePerformanceObserver;\n\ntype StopListening = undefined | void | (() => void);\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype InstrumentHandlerCallback = (data: any) => void;\n\ntype CleanupHandlerCallback = () => void;\n\nconst handlers: { [key in InstrumentHandlerType]?: InstrumentHandlerCallback[] } = {};\nconst instrumented: { [key in InstrumentHandlerType]?: boolean } = {};\n\nlet _previousCls: Metric | undefined;\nlet _previousFid: Metric | undefined;\nlet _previousLcp: Metric | undefined;\nlet _previousTtfb: Metric | undefined;\nlet _previousInp: Metric | undefined;\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 */\nexport function addClsInstrumentationHandler(\n  callback: (data: { metric: Metric }) => void,\n  stopOnCallback = false,\n): CleanupHandlerCallback {\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 */\nexport function addLcpInstrumentationHandler(\n  callback: (data: { metric: Metric }) => void,\n  stopOnCallback = false,\n): CleanupHandlerCallback {\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 */\nexport function addTtfbInstrumentationHandler(callback: (data: { metric: Metric }) => void): CleanupHandlerCallback {\n  return addMetricObserver('ttfb', callback, instrumentTtfb, _previousTtfb);\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 */\nexport function addFidInstrumentationHandler(callback: (data: { metric: Metric }) => void): CleanupHandlerCallback {\n  return addMetricObserver('fid', callback, instrumentFid, _previousFid);\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 */\nexport function addInpInstrumentationHandler(\n  callback: (data: { metric: Omit<Metric, 'entries'> & { entries: PerformanceEventTiming[] } }) => void,\n): CleanupHandlerCallback {\n  return addMetricObserver('inp', callback, instrumentInp, _previousInp);\n}\n\nexport function addPerformanceInstrumentationHandler(\n  type: 'event' | 'first-input',\n  callback: (data: { entries: ((PerformanceEntry & { target?: unknown | null }) | PerformanceEventTiming)[] }) => void,\n): CleanupHandlerCallback;\nexport function addPerformanceInstrumentationHandler(\n  type: InstrumentHandlerTypePerformanceObserver,\n  callback: (data: { entries: PerformanceEntry[] }) => void,\n): CleanupHandlerCallback;\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 */\nexport function addPerformanceInstrumentationHandler(\n  type: InstrumentHandlerTypePerformanceObserver,\n  callback: (data: { entries: PerformanceEntry[] }) => void,\n): CleanupHandlerCallback {\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: InstrumentHandlerType, data: unknown): void {\n  const typeHandlers = handlers[type];\n\n  if (!typeHandlers || !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(): StopListening {\n  return onCLS(\n    metric => {\n      triggerHandlers('cls', {\n        metric,\n      });\n      _previousCls = metric;\n    },\n    { reportAllChanges: true },\n  );\n}\n\nfunction instrumentFid(): void {\n  return onFID(metric => {\n    triggerHandlers('fid', {\n      metric,\n    });\n    _previousFid = metric;\n  });\n}\n\nfunction instrumentLcp(): StopListening {\n  return onLCP(metric => {\n    triggerHandlers('lcp', {\n      metric,\n    });\n    _previousLcp = metric;\n  });\n}\n\nfunction instrumentTtfb(): StopListening {\n  return onTTFB(metric => {\n    triggerHandlers('ttfb', {\n      metric,\n    });\n    _previousTtfb = metric;\n  });\n}\n\nfunction instrumentInp(): void {\n  return onINP(metric => {\n    triggerHandlers('inp', {\n      metric,\n    });\n    _previousInp = metric;\n  });\n}\n\nfunction addMetricObserver(\n  type: InstrumentHandlerTypeMetric,\n  callback: InstrumentHandlerCallback,\n  instrumentFn: () => StopListening,\n  previousValue: Metric | undefined,\n  stopOnCallback = false,\n): CleanupHandlerCallback {\n  addHandler(type, callback);\n\n  let stopListening: StopListening | undefined;\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: InstrumentHandlerTypePerformanceObserver): void {\n  const options: PerformanceObserverInit = {};\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: InstrumentHandlerType, handler: InstrumentHandlerCallback): void {\n  handlers[type] = handlers[type] || [];\n  (handlers[type] as InstrumentHandlerCallback[]).push(handler);\n}\n\n// Get a callback which can be called to remove the instrumentation handler\nfunction getCleanupCallback(\n  type: InstrumentHandlerType,\n  callback: InstrumentHandlerCallback,\n  stopListening: StopListening,\n): CleanupHandlerCallback {\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","import type { Options } from '@sentry/types';\n\nimport { getClient } from '../exports';\n\n// Treeshakable guard to remove all code related to tracing\ndeclare const __SENTRY_TRACING__: boolean | undefined;\n\n/**\n * Determines if tracing is currently enabled.\n *\n * Tracing is enabled when at least one of `tracesSampleRate` and `tracesSampler` is defined in the SDK config.\n */\nexport function hasTracingEnabled(\n  maybeOptions?: Pick<Options, 'tracesSampleRate' | 'tracesSampler' | 'enableTracing'> | undefined,\n): boolean {\n  if (typeof __SENTRY_TRACING__ === 'boolean' && !__SENTRY_TRACING__) {\n    return false;\n  }\n\n  const client = getClient();\n  const options = maybeOptions || (client && client.getOptions());\n  return !!options && (options.enableTracing || 'tracesSampleRate' in options || 'tracesSampler' in options);\n}\n","declare const __DEBUG_BUILD__: boolean;\n\n/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nexport const DEBUG_BUILD = __DEBUG_BUILD__;\n","export const DEFAULT_ENVIRONMENT = 'production';\n","import { SentryError } from './error';\nimport { SyncPromise, rejectedSyncPromise, resolvedSyncPromise } from './syncpromise';\n\nexport interface PromiseBuffer<T> {\n  // exposes the internal array so tests can assert on the state of it.\n  // XXX: this really should not be public api.\n  $: Array<PromiseLike<T>>;\n  add(taskProducer: () => PromiseLike<T>): PromiseLike<T>;\n  drain(timeout?: number): PromiseLike<boolean>;\n}\n\n/**\n * Creates an new PromiseBuffer object with the specified limit\n * @param limit max number of promises that can be stored in the buffer\n */\nexport function makePromiseBuffer<T>(limit?: number): PromiseBuffer<T> {\n  const buffer: Array<PromiseLike<T>> = [];\n\n  function isReady(): boolean {\n    return limit === undefined || buffer.length < limit;\n  }\n\n  /**\n   * Remove a promise from the queue.\n   *\n   * @param task Can be any PromiseLike<T>\n   * @returns Removed promise.\n   */\n  function remove(task: PromiseLike<T>): PromiseLike<T> {\n    return buffer.splice(buffer.indexOf(task), 1)[0];\n  }\n\n  /**\n   * Add a promise (representing an in-flight action) to the queue, and set it to remove itself on fulfillment.\n   *\n   * @param taskProducer A function producing any PromiseLike<T>; In previous versions this used to be `task:\n   *        PromiseLike<T>`, but under that model, Promises were instantly created on the call-site and their executor\n   *        functions therefore ran immediately. Thus, even if the buffer was full, the action still happened. By\n   *        requiring the promise to be wrapped in a function, we can defer promise creation until after the buffer\n   *        limit check.\n   * @returns The original promise.\n   */\n  function add(taskProducer: () => PromiseLike<T>): PromiseLike<T> {\n    if (!isReady()) {\n      return rejectedSyncPromise(new SentryError('Not adding Promise because buffer limit was reached.'));\n    }\n\n    // start the task and add its promise to the queue\n    const task = taskProducer();\n    if (buffer.indexOf(task) === -1) {\n      buffer.push(task);\n    }\n    void task\n      .then(() => remove(task))\n      // Use `then(null, rejectionHandler)` rather than `catch(rejectionHandler)` so that we can use `PromiseLike`\n      // rather than `Promise`. `PromiseLike` doesn't have a `.catch` method, making its polyfill smaller. (ES5 didn't\n      // have promises, so TS has to polyfill when down-compiling.)\n      .then(null, () =>\n        remove(task).then(null, () => {\n          // We have to add another catch here because `remove()` starts a new promise chain.\n        }),\n      );\n    return task;\n  }\n\n  /**\n   * Wait for all promises in the queue to resolve or for timeout to expire, whichever comes first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the queue is still non-empty. Passing `0` (or\n   * not passing anything) will make the promise wait as long as it takes for the queue to drain before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if the queue is already empty or drains before the timeout, and\n   * `false` otherwise\n   */\n  function drain(timeout?: number): PromiseLike<boolean> {\n    return new SyncPromise<boolean>((resolve, reject) => {\n      let counter = buffer.length;\n\n      if (!counter) {\n        return resolve(true);\n      }\n\n      // wait for `timeout` ms and then resolve to `false` (if not cancelled first)\n      const capturedSetTimeout = setTimeout(() => {\n        if (timeout && timeout > 0) {\n          resolve(false);\n        }\n      }, timeout);\n\n      // if all promises resolve in time, cancel the timer and resolve to `true`\n      buffer.forEach(item => {\n        void resolvedSyncPromise(item).then(() => {\n          if (!--counter) {\n            clearTimeout(capturedSetTimeout);\n            resolve(true);\n          }\n        }, reject);\n      });\n    });\n  }\n\n  return {\n    $: buffer,\n    add,\n    drain,\n  };\n}\n","import type {\n  Envelope,\n  EnvelopeItem,\n  EnvelopeItemType,\n  Event,\n  EventDropReason,\n  EventItem,\n  InternalBaseTransportOptions,\n  Transport,\n  TransportMakeRequestResponse,\n  TransportRequestExecutor,\n} from '@sentry/types';\nimport type { PromiseBuffer, RateLimits } from '@sentry/utils';\nimport {\n  SentryError,\n  createEnvelope,\n  envelopeItemTypeToDataCategory,\n  forEachEnvelopeItem,\n  isRateLimited,\n  logger,\n  makePromiseBuffer,\n  resolvedSyncPromise,\n  serializeEnvelope,\n  updateRateLimits,\n} from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../debug-build';\n\nexport const DEFAULT_TRANSPORT_BUFFER_SIZE = 30;\n\n/**\n * Creates an instance of a Sentry `Transport`\n *\n * @param options\n * @param makeRequest\n */\nexport function createTransport(\n  options: InternalBaseTransportOptions,\n  makeRequest: TransportRequestExecutor,\n  buffer: PromiseBuffer<void | TransportMakeRequestResponse> = makePromiseBuffer(\n    options.bufferSize || DEFAULT_TRANSPORT_BUFFER_SIZE,\n  ),\n): Transport {\n  let rateLimits: RateLimits = {};\n  const flush = (timeout?: number): PromiseLike<boolean> => buffer.drain(timeout);\n\n  function send(envelope: Envelope): PromiseLike<void | TransportMakeRequestResponse> {\n    const filteredEnvelopeItems: EnvelopeItem[] = [];\n\n    // Drop rate limited items from envelope\n    forEachEnvelopeItem(envelope, (item, type) => {\n      const dataCategory = envelopeItemTypeToDataCategory(type);\n      if (isRateLimited(rateLimits, dataCategory)) {\n        const event: Event | undefined = getEventForEnvelopeItem(item, type);\n        options.recordDroppedEvent('ratelimit_backoff', dataCategory, event);\n      } else {\n        filteredEnvelopeItems.push(item);\n      }\n    });\n\n    // Skip sending if envelope is empty after filtering out rate limited events\n    if (filteredEnvelopeItems.length === 0) {\n      return resolvedSyncPromise();\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const filteredEnvelope: Envelope = createEnvelope(envelope[0], filteredEnvelopeItems as any);\n\n    // Creates client report for each item in an envelope\n    const recordEnvelopeLoss = (reason: EventDropReason): void => {\n      forEachEnvelopeItem(filteredEnvelope, (item, type) => {\n        const event: Event | undefined = getEventForEnvelopeItem(item, type);\n        options.recordDroppedEvent(reason, envelopeItemTypeToDataCategory(type), event);\n      });\n    };\n\n    const requestTask = (): PromiseLike<void | TransportMakeRequestResponse> =>\n      makeRequest({ body: serializeEnvelope(filteredEnvelope, options.textEncoder) }).then(\n        response => {\n          // We don't want to throw on NOK responses, but we want to at least log them\n          if (response.statusCode !== undefined && (response.statusCode < 200 || response.statusCode >= 300)) {\n            DEBUG_BUILD && logger.warn(`Sentry responded with status code ${response.statusCode} to sent event.`);\n          }\n\n          rateLimits = updateRateLimits(rateLimits, response);\n          return response;\n        },\n        error => {\n          recordEnvelopeLoss('network_error');\n          throw error;\n        },\n      );\n\n    return buffer.add(requestTask).then(\n      result => result,\n      error => {\n        if (error instanceof SentryError) {\n          DEBUG_BUILD && logger.error('Skipped sending event because buffer is full.');\n          recordEnvelopeLoss('queue_overflow');\n          return resolvedSyncPromise();\n        } else {\n          throw error;\n        }\n      },\n    );\n  }\n\n  // We use this to identifify if the transport is the base transport\n  // TODO (v8): Remove this again as we'll no longer need it\n  send.__sentry__baseTransport__ = true;\n\n  return {\n    send,\n    flush,\n  };\n}\n\nfunction getEventForEnvelopeItem(item: Envelope[1][number], type: EnvelopeItemType): Event | undefined {\n  if (type !== 'event' && type !== 'transaction') {\n    return undefined;\n  }\n\n  return Array.isArray(item) ? (item as EventItem)[1] : undefined;\n}\n","import type { ConsoleLevel } from '@sentry/types';\n\n/** An error emitted by Sentry SDKs and related utilities. */\nexport class SentryError extends Error {\n  /** Display name of this error instance. */\n  public name: string;\n\n  public logLevel: ConsoleLevel;\n\n  public constructor(public message: string, logLevel: ConsoleLevel = 'warn') {\n    super(message);\n\n    this.name = new.target.prototype.constructor.name;\n    // This sets the prototype to be `Error`, not `SentryError`. It's unclear why we do this, but commenting this line\n    // out causes various (seemingly totally unrelated) playwright tests consistently time out. FYI, this makes\n    // instances of `SentryError` fail `obj instanceof SentryError` checks.\n    Object.setPrototypeOf(this, new.target.prototype);\n    this.logLevel = logLevel;\n  }\n}\n","import type { Event, EventHint, EventProcessor } from '@sentry/types';\nimport { SyncPromise, getGlobalSingleton, isThenable, logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from './debug-build';\n\n/**\n * Returns the global event processors.\n * @deprecated Global event processors will be removed in v8.\n */\nexport function getGlobalEventProcessors(): EventProcessor[] {\n  return getGlobalSingleton<EventProcessor[]>('globalEventProcessors', () => []);\n}\n\n/**\n * Add a EventProcessor to be kept globally.\n * @deprecated Use `addEventProcessor` instead. Global event processors will be removed in v8.\n */\nexport function addGlobalEventProcessor(callback: EventProcessor): void {\n  // eslint-disable-next-line deprecation/deprecation\n  getGlobalEventProcessors().push(callback);\n}\n\n/**\n * Process an array of event processors, returning the processed event (or `null` if the event was dropped).\n */\nexport function notifyEventProcessors(\n  processors: EventProcessor[],\n  event: Event | null,\n  hint: EventHint,\n  index: number = 0,\n): PromiseLike<Event | null> {\n  return new SyncPromise<Event | null>((resolve, reject) => {\n    const processor = processors[index];\n    if (event === null || typeof processor !== 'function') {\n      resolve(event);\n    } else {\n      const result = processor({ ...event }, hint) as Event | null;\n\n      DEBUG_BUILD && processor.id && result === null && logger.log(`Event processor \"${processor.id}\" dropped event`);\n\n      if (isThenable(result)) {\n        void result\n          .then(final => notifyEventProcessors(processors, final, hint, index + 1).then(resolve))\n          .then(null, reject);\n      } else {\n        void notifyEventProcessors(processors, result, hint, index + 1)\n          .then(resolve)\n          .then(null, reject);\n      }\n    }\n  });\n}\n","/* eslint-disable max-lines */\nimport type {\n  Attachment,\n  Breadcrumb,\n  CaptureContext,\n  Client,\n  Context,\n  Contexts,\n  Event,\n  EventHint,\n  EventProcessor,\n  Extra,\n  Extras,\n  Primitive,\n  PropagationContext,\n  RequestSession,\n  Scope as ScopeInterface,\n  ScopeContext,\n  ScopeData,\n  Session,\n  Severity,\n  SeverityLevel,\n  Span,\n  Transaction,\n  User,\n} from '@sentry/types';\nimport { dateTimestampInSeconds, isPlainObject, logger, uuid4 } from '@sentry/utils';\n\nimport { getGlobalEventProcessors, notifyEventProcessors } from './eventProcessors';\nimport { updateSession } from './session';\nimport { applyScopeDataToEvent } from './utils/applyScopeDataToEvent';\n\n/**\n * Default value for maximum number of breadcrumbs added to an event.\n */\nconst DEFAULT_MAX_BREADCRUMBS = 100;\n\n/**\n * The global scope is kept in this module.\n * When accessing this via `getGlobalScope()` we'll make sure to set one if none is currently present.\n */\nlet globalScope: ScopeInterface | undefined;\n\n/**\n * Holds additional event information. {@link Scope.applyToEvent} will be\n * called by the client before an event will be sent.\n */\nexport class Scope implements ScopeInterface {\n  /** Flag if notifying is happening. */\n  protected _notifyingListeners: boolean;\n\n  /** Callback for client to receive scope changes. */\n  protected _scopeListeners: Array<(scope: Scope) => void>;\n\n  /** Callback list that will be called after {@link applyToEvent}. */\n  protected _eventProcessors: EventProcessor[];\n\n  /** Array of breadcrumbs. */\n  protected _breadcrumbs: Breadcrumb[];\n\n  /** User */\n  protected _user: User;\n\n  /** Tags */\n  protected _tags: { [key: string]: Primitive };\n\n  /** Extra */\n  protected _extra: Extras;\n\n  /** Contexts */\n  protected _contexts: Contexts;\n\n  /** Attachments */\n  protected _attachments: Attachment[];\n\n  /** Propagation Context for distributed tracing */\n  protected _propagationContext: PropagationContext;\n\n  /**\n   * A place to stash data which is needed at some point in the SDK's event processing pipeline but which shouldn't get\n   * sent to Sentry\n   */\n  protected _sdkProcessingMetadata: { [key: string]: unknown };\n\n  /** Fingerprint */\n  protected _fingerprint?: string[];\n\n  /** Severity */\n  // eslint-disable-next-line deprecation/deprecation\n  protected _level?: Severity | SeverityLevel;\n\n  /**\n   * Transaction Name\n   */\n  protected _transactionName?: string;\n\n  /** Span */\n  protected _span?: Span;\n\n  /** Session */\n  protected _session?: Session;\n\n  /** Request Mode Session Status */\n  protected _requestSession?: RequestSession;\n\n  /** The client on this scope */\n  protected _client?: Client;\n\n  // NOTE: Any field which gets added here should get added not only to the constructor but also to the `clone` method.\n\n  public constructor() {\n    this._notifyingListeners = false;\n    this._scopeListeners = [];\n    this._eventProcessors = [];\n    this._breadcrumbs = [];\n    this._attachments = [];\n    this._user = {};\n    this._tags = {};\n    this._extra = {};\n    this._contexts = {};\n    this._sdkProcessingMetadata = {};\n    this._propagationContext = generatePropagationContext();\n  }\n\n  /**\n   * Inherit values from the parent scope.\n   * @deprecated Use `scope.clone()` and `new Scope()` instead.\n   */\n  public static clone(scope?: Scope): Scope {\n    return scope ? scope.clone() : new Scope();\n  }\n\n  /**\n   * Clone this scope instance.\n   */\n  public clone(): Scope {\n    const newScope = new Scope();\n    newScope._breadcrumbs = [...this._breadcrumbs];\n    newScope._tags = { ...this._tags };\n    newScope._extra = { ...this._extra };\n    newScope._contexts = { ...this._contexts };\n    newScope._user = this._user;\n    newScope._level = this._level;\n    newScope._span = this._span;\n    newScope._session = this._session;\n    newScope._transactionName = this._transactionName;\n    newScope._fingerprint = this._fingerprint;\n    newScope._eventProcessors = [...this._eventProcessors];\n    newScope._requestSession = this._requestSession;\n    newScope._attachments = [...this._attachments];\n    newScope._sdkProcessingMetadata = { ...this._sdkProcessingMetadata };\n    newScope._propagationContext = { ...this._propagationContext };\n    newScope._client = this._client;\n\n    return newScope;\n  }\n\n  /** Update the client on the scope. */\n  public setClient(client: Client | undefined): void {\n    this._client = client;\n  }\n\n  /**\n   * Get the client assigned to this scope.\n   *\n   * It is generally recommended to use the global function `Sentry.getClient()` instead, unless you know what you are doing.\n   */\n  public getClient(): Client | undefined {\n    return this._client;\n  }\n\n  /**\n   * Add internal on change listener. Used for sub SDKs that need to store the scope.\n   * @hidden\n   */\n  public addScopeListener(callback: (scope: Scope) => void): void {\n    this._scopeListeners.push(callback);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addEventProcessor(callback: EventProcessor): this {\n    this._eventProcessors.push(callback);\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setUser(user: User | null): this {\n    // If null is passed we want to unset everything, but still define keys,\n    // so that later down in the pipeline any existing values are cleared.\n    this._user = user || {\n      email: undefined,\n      id: undefined,\n      ip_address: undefined,\n      segment: undefined,\n      username: undefined,\n    };\n\n    if (this._session) {\n      updateSession(this._session, { user });\n    }\n\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getUser(): User | undefined {\n    return this._user;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getRequestSession(): RequestSession | undefined {\n    return this._requestSession;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setRequestSession(requestSession?: RequestSession): this {\n    this._requestSession = requestSession;\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTags(tags: { [key: string]: Primitive }): this {\n    this._tags = {\n      ...this._tags,\n      ...tags,\n    };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setTag(key: string, value: Primitive): this {\n    this._tags = { ...this._tags, [key]: value };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setExtras(extras: Extras): this {\n    this._extra = {\n      ...this._extra,\n      ...extras,\n    };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setExtra(key: string, extra: Extra): this {\n    this._extra = { ...this._extra, [key]: extra };\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setFingerprint(fingerprint: string[]): this {\n    this._fingerprint = fingerprint;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setLevel(\n    // eslint-disable-next-line deprecation/deprecation\n    level: Severity | SeverityLevel,\n  ): this {\n    this._level = level;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Sets the transaction name on the scope for future events.\n   */\n  public setTransactionName(name?: string): this {\n    this._transactionName = name;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setContext(key: string, context: Context | null): this {\n    if (context === null) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete this._contexts[key];\n    } else {\n      this._contexts[key] = context;\n    }\n\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Sets the Span on the scope.\n   * @param span Span\n   * @deprecated Instead of setting a span on a scope, use `startSpan()`/`startSpanManual()` instead.\n   */\n  public setSpan(span?: Span): this {\n    this._span = span;\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * Returns the `Span` if there is one.\n   * @deprecated Use `getActiveSpan()` instead.\n   */\n  public getSpan(): Span | undefined {\n    return this._span;\n  }\n\n  /**\n   * Returns the `Transaction` attached to the scope (if there is one).\n   * @deprecated You should not rely on the transaction, but just use `startSpan()` APIs instead.\n   */\n  public getTransaction(): Transaction | undefined {\n    // Often, this span (if it exists at all) will be a transaction, but it's not guaranteed to be. Regardless, it will\n    // have a pointer to the currently-active transaction.\n    const span = this._span;\n    // Cannot replace with getRootSpan because getRootSpan returns a span, not a transaction\n    // Also, this method will be removed anyway.\n    // eslint-disable-next-line deprecation/deprecation\n    return span && span.transaction;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setSession(session?: Session): this {\n    if (!session) {\n      delete this._session;\n    } else {\n      this._session = session;\n    }\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getSession(): Session | undefined {\n    return this._session;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public update(captureContext?: CaptureContext): this {\n    if (!captureContext) {\n      return this;\n    }\n\n    const scopeToMerge = typeof captureContext === 'function' ? captureContext(this) : captureContext;\n\n    if (scopeToMerge instanceof Scope) {\n      const scopeData = scopeToMerge.getScopeData();\n\n      this._tags = { ...this._tags, ...scopeData.tags };\n      this._extra = { ...this._extra, ...scopeData.extra };\n      this._contexts = { ...this._contexts, ...scopeData.contexts };\n      if (scopeData.user && Object.keys(scopeData.user).length) {\n        this._user = scopeData.user;\n      }\n      if (scopeData.level) {\n        this._level = scopeData.level;\n      }\n      if (scopeData.fingerprint.length) {\n        this._fingerprint = scopeData.fingerprint;\n      }\n      if (scopeToMerge.getRequestSession()) {\n        this._requestSession = scopeToMerge.getRequestSession();\n      }\n      if (scopeData.propagationContext) {\n        this._propagationContext = scopeData.propagationContext;\n      }\n    } else if (isPlainObject(scopeToMerge)) {\n      const scopeContext = captureContext as ScopeContext;\n      this._tags = { ...this._tags, ...scopeContext.tags };\n      this._extra = { ...this._extra, ...scopeContext.extra };\n      this._contexts = { ...this._contexts, ...scopeContext.contexts };\n      if (scopeContext.user) {\n        this._user = scopeContext.user;\n      }\n      if (scopeContext.level) {\n        this._level = scopeContext.level;\n      }\n      if (scopeContext.fingerprint) {\n        this._fingerprint = scopeContext.fingerprint;\n      }\n      if (scopeContext.requestSession) {\n        this._requestSession = scopeContext.requestSession;\n      }\n      if (scopeContext.propagationContext) {\n        this._propagationContext = scopeContext.propagationContext;\n      }\n    }\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public clear(): this {\n    this._breadcrumbs = [];\n    this._tags = {};\n    this._extra = {};\n    this._user = {};\n    this._contexts = {};\n    this._level = undefined;\n    this._transactionName = undefined;\n    this._fingerprint = undefined;\n    this._requestSession = undefined;\n    this._span = undefined;\n    this._session = undefined;\n    this._notifyScopeListeners();\n    this._attachments = [];\n    this._propagationContext = generatePropagationContext();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addBreadcrumb(breadcrumb: Breadcrumb, maxBreadcrumbs?: number): this {\n    const maxCrumbs = typeof maxBreadcrumbs === 'number' ? maxBreadcrumbs : DEFAULT_MAX_BREADCRUMBS;\n\n    // No data has been changed, so don't notify scope listeners\n    if (maxCrumbs <= 0) {\n      return this;\n    }\n\n    const mergedBreadcrumb = {\n      timestamp: dateTimestampInSeconds(),\n      ...breadcrumb,\n    };\n\n    const breadcrumbs = this._breadcrumbs;\n    breadcrumbs.push(mergedBreadcrumb);\n    this._breadcrumbs = breadcrumbs.length > maxCrumbs ? breadcrumbs.slice(-maxCrumbs) : breadcrumbs;\n\n    this._notifyScopeListeners();\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getLastBreadcrumb(): Breadcrumb | undefined {\n    return this._breadcrumbs[this._breadcrumbs.length - 1];\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public clearBreadcrumbs(): this {\n    this._breadcrumbs = [];\n    this._notifyScopeListeners();\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addAttachment(attachment: Attachment): this {\n    this._attachments.push(attachment);\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   * @deprecated Use `getScopeData()` instead.\n   */\n  public getAttachments(): Attachment[] {\n    const data = this.getScopeData();\n\n    return data.attachments;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public clearAttachments(): this {\n    this._attachments = [];\n    return this;\n  }\n\n  /** @inheritDoc */\n  public getScopeData(): ScopeData {\n    const {\n      _breadcrumbs,\n      _attachments,\n      _contexts,\n      _tags,\n      _extra,\n      _user,\n      _level,\n      _fingerprint,\n      _eventProcessors,\n      _propagationContext,\n      _sdkProcessingMetadata,\n      _transactionName,\n      _span,\n    } = this;\n\n    return {\n      breadcrumbs: _breadcrumbs,\n      attachments: _attachments,\n      contexts: _contexts,\n      tags: _tags,\n      extra: _extra,\n      user: _user,\n      level: _level,\n      fingerprint: _fingerprint || [],\n      eventProcessors: _eventProcessors,\n      propagationContext: _propagationContext,\n      sdkProcessingMetadata: _sdkProcessingMetadata,\n      transactionName: _transactionName,\n      span: _span,\n    };\n  }\n\n  /**\n   * Applies data from the scope to the event and runs all event processors on it.\n   *\n   * @param event Event\n   * @param hint Object containing additional information about the original exception, for use by the event processors.\n   * @hidden\n   * @deprecated Use `applyScopeDataToEvent()` directly\n   */\n  public applyToEvent(\n    event: Event,\n    hint: EventHint = {},\n    additionalEventProcessors: EventProcessor[] = [],\n  ): PromiseLike<Event | null> {\n    applyScopeDataToEvent(event, this.getScopeData());\n\n    // TODO (v8): Update this order to be: Global > Client > Scope\n    const eventProcessors: EventProcessor[] = [\n      ...additionalEventProcessors,\n      // eslint-disable-next-line deprecation/deprecation\n      ...getGlobalEventProcessors(),\n      ...this._eventProcessors,\n    ];\n\n    return notifyEventProcessors(eventProcessors, event, hint);\n  }\n\n  /**\n   * Add data which will be accessible during event processing but won't get sent to Sentry\n   */\n  public setSDKProcessingMetadata(newData: { [key: string]: unknown }): this {\n    this._sdkProcessingMetadata = { ...this._sdkProcessingMetadata, ...newData };\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setPropagationContext(context: PropagationContext): this {\n    this._propagationContext = context;\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getPropagationContext(): PropagationContext {\n    return this._propagationContext;\n  }\n\n  /**\n   * Capture an exception for this scope.\n   *\n   * @param exception The exception to capture.\n   * @param hint Optinal additional data to attach to the Sentry event.\n   * @returns the id of the captured Sentry event.\n   */\n  public captureException(exception: unknown, hint?: EventHint): string {\n    const eventId = hint && hint.event_id ? hint.event_id : uuid4();\n\n    if (!this._client) {\n      logger.warn('No client configured on scope - will not capture exception!');\n      return eventId;\n    }\n\n    const syntheticException = new Error('Sentry syntheticException');\n\n    this._client.captureException(\n      exception,\n      {\n        originalException: exception,\n        syntheticException,\n        ...hint,\n        event_id: eventId,\n      },\n      this,\n    );\n\n    return eventId;\n  }\n\n  /**\n   * Capture a message for this scope.\n   *\n   * @param message The message to capture.\n   * @param level An optional severity level to report the message with.\n   * @param hint Optional additional data to attach to the Sentry event.\n   * @returns the id of the captured message.\n   */\n  public captureMessage(message: string, level?: SeverityLevel, hint?: EventHint): string {\n    const eventId = hint && hint.event_id ? hint.event_id : uuid4();\n\n    if (!this._client) {\n      logger.warn('No client configured on scope - will not capture message!');\n      return eventId;\n    }\n\n    const syntheticException = new Error(message);\n\n    this._client.captureMessage(\n      message,\n      level,\n      {\n        originalException: message,\n        syntheticException,\n        ...hint,\n        event_id: eventId,\n      },\n      this,\n    );\n\n    return eventId;\n  }\n\n  /**\n   * Captures a manually created event for this scope and sends it to Sentry.\n   *\n   * @param exception The event to capture.\n   * @param hint Optional additional data to attach to the Sentry event.\n   * @returns the id of the captured event.\n   */\n  public captureEvent(event: Event, hint?: EventHint): string {\n    const eventId = hint && hint.event_id ? hint.event_id : uuid4();\n\n    if (!this._client) {\n      logger.warn('No client configured on scope - will not capture event!');\n      return eventId;\n    }\n\n    this._client.captureEvent(event, { ...hint, event_id: eventId }, this);\n\n    return eventId;\n  }\n\n  /**\n   * This will be called on every set call.\n   */\n  protected _notifyScopeListeners(): void {\n    // We need this check for this._notifyingListeners to be able to work on scope during updates\n    // If this check is not here we'll produce endless recursion when something is done with the scope\n    // during the callback.\n    if (!this._notifyingListeners) {\n      this._notifyingListeners = true;\n      this._scopeListeners.forEach(callback => {\n        callback(this);\n      });\n      this._notifyingListeners = false;\n    }\n  }\n}\n\n/**\n * Get the global scope.\n * This scope is applied to _all_ events.\n */\nexport function getGlobalScope(): ScopeInterface {\n  if (!globalScope) {\n    globalScope = new Scope();\n  }\n\n  return globalScope;\n}\n\n/**\n * This is mainly needed for tests.\n * DO NOT USE this, as this is an internal API and subject to change.\n * @hidden\n */\nexport function setGlobalScope(scope: ScopeInterface | undefined): void {\n  globalScope = scope;\n}\n\nfunction generatePropagationContext(): PropagationContext {\n  return {\n    traceId: uuid4(),\n    spanId: uuid4().substring(16),\n  };\n}\n","import { GLOBAL_OBJ } from './worldwide';\n\nconst ONE_SECOND_IN_MS = 1000;\n\n/**\n * A partial definition of the [Performance Web API]{@link https://developer.mozilla.org/en-US/docs/Web/API/Performance}\n * for accessing a high-resolution monotonic clock.\n */\ninterface Performance {\n  /**\n   * The millisecond timestamp at which measurement began, measured in Unix time.\n   */\n  timeOrigin: number;\n  /**\n   * Returns the current millisecond timestamp, where 0 represents the start of measurement.\n   */\n  now(): number;\n}\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using the Date API.\n *\n * TODO(v8): Return type should be rounded.\n */\nexport function dateTimestampInSeconds(): number {\n  return Date.now() / ONE_SECOND_IN_MS;\n}\n\n/**\n * Returns a wrapper around the native Performance API browser implementation, or undefined for browsers that do not\n * support the API.\n *\n * Wrapping the native API works around differences in behavior from different browsers.\n */\nfunction createUnixTimestampInSecondsFunc(): () => number {\n  const { performance } = GLOBAL_OBJ as typeof GLOBAL_OBJ & { performance?: Performance };\n  if (!performance || !performance.now) {\n    return dateTimestampInSeconds;\n  }\n\n  // Some browser and environments don't have a timeOrigin, so we fallback to\n  // using Date.now() to compute the starting time.\n  const approxStartingTimeOrigin = Date.now() - performance.now();\n  const timeOrigin = performance.timeOrigin == undefined ? approxStartingTimeOrigin : performance.timeOrigin;\n\n  // performance.now() is a monotonic clock, which means it starts at 0 when the process begins. To get the current\n  // wall clock time (actual UNIX timestamp), we need to add the starting time origin and the current time elapsed.\n  //\n  // TODO: This does not account for the case where the monotonic clock that powers performance.now() drifts from the\n  // wall clock time, which causes the returned timestamp to be inaccurate. We should investigate how to detect and\n  // correct for this.\n  // See: https://github.com/getsentry/sentry-javascript/issues/2590\n  // See: https://github.com/mdn/content/issues/4713\n  // See: https://dev.to/noamr/when-a-millisecond-is-not-a-millisecond-3h6\n  return () => {\n    return (timeOrigin + performance.now()) / ONE_SECOND_IN_MS;\n  };\n}\n\n/**\n * Returns a timestamp in seconds since the UNIX epoch using either the Performance or Date APIs, depending on the\n * availability of the Performance API.\n *\n * BUG: Note that because of how browsers implement the Performance API, the clock might stop when the computer is\n * asleep. This creates a skew between `dateTimestampInSeconds` and `timestampInSeconds`. The\n * skew can grow to arbitrary amounts like days, weeks or months.\n * See https://github.com/getsentry/sentry-javascript/issues/2590.\n */\nexport const timestampInSeconds = createUnixTimestampInSecondsFunc();\n\n/**\n * Re-exported with an old name for backwards-compatibility.\n * TODO (v8): Remove this\n *\n * @deprecated Use `timestampInSeconds` instead.\n */\nexport const timestampWithMs = timestampInSeconds;\n\n/**\n * Internal helper to store what is the source of browserPerformanceTimeOrigin below. For debugging only.\n */\nexport let _browserPerformanceTimeOriginMode: string;\n\n/**\n * The number of milliseconds since the UNIX epoch. This value is only usable in a browser, and only when the\n * performance API is available.\n */\nexport const browserPerformanceTimeOrigin = ((): number | undefined => {\n  // Unfortunately browsers may report an inaccurate time origin data, through either performance.timeOrigin or\n  // performance.timing.navigationStart, which results in poor results in performance data. We only treat time origin\n  // data as reliable if they are within a reasonable threshold of the current time.\n\n  const { performance } = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;\n  if (!performance || !performance.now) {\n    _browserPerformanceTimeOriginMode = 'none';\n    return undefined;\n  }\n\n  const threshold = 3600 * 1000;\n  const performanceNow = performance.now();\n  const dateNow = Date.now();\n\n  // if timeOrigin isn't available set delta to threshold so it isn't used\n  const timeOriginDelta = performance.timeOrigin\n    ? Math.abs(performance.timeOrigin + performanceNow - dateNow)\n    : threshold;\n  const timeOriginIsReliable = timeOriginDelta < threshold;\n\n  // While performance.timing.navigationStart is deprecated in favor of performance.timeOrigin, performance.timeOrigin\n  // is not as widely supported. Namely, performance.timeOrigin is undefined in Safari as of writing.\n  // Also as of writing, performance.timing is not available in Web Workers in mainstream browsers, so it is not always\n  // a valid fallback. In the absence of an initial time provided by the browser, fallback to the current time from the\n  // Date API.\n  // eslint-disable-next-line deprecation/deprecation\n  const navigationStart = performance.timing && performance.timing.navigationStart;\n  const hasNavigationStart = typeof navigationStart === 'number';\n  // if navigationStart isn't available set delta to threshold so it isn't used\n  const navigationStartDelta = hasNavigationStart ? Math.abs(navigationStart + performanceNow - dateNow) : threshold;\n  const navigationStartIsReliable = navigationStartDelta < threshold;\n\n  if (timeOriginIsReliable || navigationStartIsReliable) {\n    // Use the more reliable time origin\n    if (timeOriginDelta <= navigationStartDelta) {\n      _browserPerformanceTimeOriginMode = 'timeOrigin';\n      return performance.timeOrigin;\n    } else {\n      _browserPerformanceTimeOriginMode = 'navigationStart';\n      return navigationStart;\n    }\n  }\n\n  // Either both timeOrigin and navigationStart are skewed or neither is available, fallback to Date.\n  _browserPerformanceTimeOriginMode = 'dateNow';\n  return dateNow;\n})();\n","import type {\n  Breadcrumb,\n  BreadcrumbHint,\n  CaptureContext,\n  CheckIn,\n  Client,\n  CustomSamplingContext,\n  Event,\n  EventHint,\n  Extra,\n  Extras,\n  FinishedCheckIn,\n  MonitorConfig,\n  Primitive,\n  Scope as ScopeInterface,\n  Session,\n  SessionContext,\n  Severity,\n  SeverityLevel,\n  Span,\n  TransactionContext,\n  User,\n} from '@sentry/types';\nimport { GLOBAL_OBJ, isThenable, logger, timestampInSeconds, uuid4 } from '@sentry/utils';\n\nimport { DEFAULT_ENVIRONMENT } from './constants';\nimport { DEBUG_BUILD } from './debug-build';\nimport type { Hub } from './hub';\nimport { runWithAsyncContext } from './hub';\nimport { getCurrentHub, getIsolationScope } from './hub';\nimport type { Scope } from './scope';\nimport { closeSession, makeSession, updateSession } from './session';\nimport type { ExclusiveEventHintOrCaptureContext } from './utils/prepareEvent';\nimport { parseEventHintOrCaptureContext } from './utils/prepareEvent';\n\n/**\n * Captures an exception event and sends it to Sentry.\n *\n * @param exception The exception to capture.\n * @param hint Optional additional data to attach to the Sentry event.\n * @returns the id of the captured Sentry event.\n */\nexport function captureException(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  exception: any,\n  hint?: ExclusiveEventHintOrCaptureContext,\n): string {\n  // eslint-disable-next-line deprecation/deprecation\n  return getCurrentHub().captureException(exception, parseEventHintOrCaptureContext(hint));\n}\n\n/**\n * Captures a message event and sends it to Sentry.\n *\n * @param exception The exception to capture.\n * @param captureContext Define the level of the message or pass in additional data to attach to the message.\n * @returns the id of the captured message.\n */\nexport function captureMessage(\n  message: string,\n  // eslint-disable-next-line deprecation/deprecation\n  captureContext?: CaptureContext | Severity | SeverityLevel,\n): string {\n  // This is necessary to provide explicit scopes upgrade, without changing the original\n  // arity of the `captureMessage(message, level)` method.\n  const level = typeof captureContext === 'string' ? captureContext : undefined;\n  const context = typeof captureContext !== 'string' ? { captureContext } : undefined;\n  // eslint-disable-next-line deprecation/deprecation\n  return getCurrentHub().captureMessage(message, level, context);\n}\n\n/**\n * Captures a manually created event and sends it to Sentry.\n *\n * @param exception The event to send to Sentry.\n * @param hint Optional additional data to attach to the Sentry event.\n * @returns the id of the captured event.\n */\nexport function captureEvent(event: Event, hint?: EventHint): string {\n  // eslint-disable-next-line deprecation/deprecation\n  return getCurrentHub().captureEvent(event, hint);\n}\n\n/**\n * Callback to set context information onto the scope.\n * @param callback Callback function that receives Scope.\n *\n * @deprecated Use getCurrentScope() directly.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport function configureScope(callback: (scope: Scope) => void): ReturnType<Hub['configureScope']> {\n  // eslint-disable-next-line deprecation/deprecation\n  getCurrentHub().configureScope(callback);\n}\n\n/**\n * Records a new breadcrumb which will be attached to future events.\n *\n * Breadcrumbs will be added to subsequent events to provide more context on\n * user's actions prior to an error or crash.\n *\n * @param breadcrumb The breadcrumb to record.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport function addBreadcrumb(breadcrumb: Breadcrumb, hint?: BreadcrumbHint): ReturnType<Hub['addBreadcrumb']> {\n  // eslint-disable-next-line deprecation/deprecation\n  getCurrentHub().addBreadcrumb(breadcrumb, hint);\n}\n\n/**\n * Sets context data with the given name.\n * @param name of the context\n * @param context Any kind of data. This data will be normalized.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any, deprecation/deprecation\nexport function setContext(name: string, context: { [key: string]: any } | null): ReturnType<Hub['setContext']> {\n  // eslint-disable-next-line deprecation/deprecation\n  getCurrentHub().setContext(name, context);\n}\n\n/**\n * Set an object that will be merged sent as extra data with the event.\n * @param extras Extras object to merge into current context.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport function setExtras(extras: Extras): ReturnType<Hub['setExtras']> {\n  // eslint-disable-next-line deprecation/deprecation\n  getCurrentHub().setExtras(extras);\n}\n\n/**\n * Set key:value that will be sent as extra data with the event.\n * @param key String of extra\n * @param extra Any kind of data. This data will be normalized.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport function setExtra(key: string, extra: Extra): ReturnType<Hub['setExtra']> {\n  // eslint-disable-next-line deprecation/deprecation\n  getCurrentHub().setExtra(key, extra);\n}\n\n/**\n * Set an object that will be merged sent as tags data with the event.\n * @param tags Tags context object to merge into current context.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport function setTags(tags: { [key: string]: Primitive }): ReturnType<Hub['setTags']> {\n  // eslint-disable-next-line deprecation/deprecation\n  getCurrentHub().setTags(tags);\n}\n\n/**\n * Set key:value that will be sent as tags data with the event.\n *\n * Can also be used to unset a tag, by passing `undefined`.\n *\n * @param key String key of tag\n * @param value Value of tag\n */\n// eslint-disable-next-line deprecation/deprecation\nexport function setTag(key: string, value: Primitive): ReturnType<Hub['setTag']> {\n  // eslint-disable-next-line deprecation/deprecation\n  getCurrentHub().setTag(key, value);\n}\n\n/**\n * Updates user context information for future events.\n *\n * @param user User context object to be set in the current context. Pass `null` to unset the user.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport function setUser(user: User | null): ReturnType<Hub['setUser']> {\n  // eslint-disable-next-line deprecation/deprecation\n  getCurrentHub().setUser(user);\n}\n\n/**\n * Creates a new scope with and executes the given operation within.\n * The scope is automatically removed once the operation\n * finishes or throws.\n *\n * This is essentially a convenience function for:\n *\n *     pushScope();\n *     callback();\n *     popScope();\n */\nexport function withScope<T>(callback: (scope: Scope) => T): T;\n/**\n * Set the given scope as the active scope in the callback.\n */\nexport function withScope<T>(scope: ScopeInterface | undefined, callback: (scope: Scope) => T): T;\n/**\n * Either creates a new active scope, or sets the given scope as active scope in the given callback.\n */\nexport function withScope<T>(\n  ...rest: [callback: (scope: Scope) => T] | [scope: ScopeInterface | undefined, callback: (scope: Scope) => T]\n): T {\n  // eslint-disable-next-line deprecation/deprecation\n  const hub = getCurrentHub();\n\n  // If a scope is defined, we want to make this the active scope instead of the default one\n  if (rest.length === 2) {\n    const [scope, callback] = rest;\n    if (!scope) {\n      // eslint-disable-next-line deprecation/deprecation\n      return hub.withScope(callback);\n    }\n\n    // eslint-disable-next-line deprecation/deprecation\n    return hub.withScope(() => {\n      // eslint-disable-next-line deprecation/deprecation\n      hub.getStackTop().scope = scope as Scope;\n      return callback(scope as Scope);\n    });\n  }\n\n  // eslint-disable-next-line deprecation/deprecation\n  return hub.withScope(rest[0]);\n}\n\n/**\n * Attempts to fork the current isolation scope and the current scope based on the current async context strategy. If no\n * async context strategy is set, the isolation scope and the current scope will not be forked (this is currently the\n * case, for example, in the browser).\n *\n * Usage of this function in environments without async context strategy is discouraged and may lead to unexpected behaviour.\n *\n * This function is intended for Sentry SDK and SDK integration development. It is not recommended to be used in \"normal\"\n * applications directly because it comes with pitfalls. Use at your own risk!\n *\n * @param callback The callback in which the passed isolation scope is active. (Note: In environments without async\n * context strategy, the currently active isolation scope may change within execution of the callback.)\n * @returns The same value that `callback` returns.\n */\nexport function withIsolationScope<T>(callback: (isolationScope: Scope) => T): T {\n  return runWithAsyncContext(() => {\n    return callback(getIsolationScope());\n  });\n}\n\n/**\n * Forks the current scope and sets the provided span as active span in the context of the provided callback.\n *\n * @param span Spans started in the context of the provided callback will be children of this span.\n * @param callback Execution context in which the provided span will be active. Is passed the newly forked scope.\n * @returns the value returned from the provided callback function.\n */\nexport function withActiveSpan<T>(span: Span, callback: (scope: Scope) => T): T {\n  return withScope(scope => {\n    // eslint-disable-next-line deprecation/deprecation\n    scope.setSpan(span);\n    return callback(scope);\n  });\n}\n\n/**\n * Starts a new `Transaction` and returns it. This is the entry point to manual tracing instrumentation.\n *\n * A tree structure can be built by adding child spans to the transaction, and child spans to other spans. To start a\n * new child span within the transaction or any span, call the respective `.startChild()` method.\n *\n * Every child span must be finished before the transaction is finished, otherwise the unfinished spans are discarded.\n *\n * The transaction must be finished with a call to its `.end()` method, at which point the transaction with all its\n * finished child spans will be sent to Sentry.\n *\n * NOTE: This function should only be used for *manual* instrumentation. Auto-instrumentation should call\n * `startTransaction` directly on the hub.\n *\n * @param context Properties of the new `Transaction`.\n * @param customSamplingContext Information given to the transaction sampling function (along with context-dependent\n * default values). See {@link Options.tracesSampler}.\n *\n * @returns The transaction which was just started\n *\n * @deprecated Use `startSpan()`, `startSpanManual()` or `startInactiveSpan()` instead.\n */\nexport function startTransaction(\n  context: TransactionContext,\n  customSamplingContext?: CustomSamplingContext,\n  // eslint-disable-next-line deprecation/deprecation\n): ReturnType<Hub['startTransaction']> {\n  // eslint-disable-next-line deprecation/deprecation\n  return getCurrentHub().startTransaction({ ...context }, customSamplingContext);\n}\n\n/**\n * Create a cron monitor check in and send it to Sentry.\n *\n * @param checkIn An object that describes a check in.\n * @param upsertMonitorConfig An optional object that describes a monitor config. Use this if you want\n * to create a monitor automatically when sending a check in.\n */\nexport function captureCheckIn(checkIn: CheckIn, upsertMonitorConfig?: MonitorConfig): string {\n  const scope = getCurrentScope();\n  const client = getClient();\n  if (!client) {\n    DEBUG_BUILD && logger.warn('Cannot capture check-in. No client defined.');\n  } else if (!client.captureCheckIn) {\n    DEBUG_BUILD && logger.warn('Cannot capture check-in. Client does not support sending check-ins.');\n  } else {\n    return client.captureCheckIn(checkIn, upsertMonitorConfig, scope);\n  }\n\n  return uuid4();\n}\n\n/**\n * Wraps a callback with a cron monitor check in. The check in will be sent to Sentry when the callback finishes.\n *\n * @param monitorSlug The distinct slug of the monitor.\n * @param upsertMonitorConfig An optional object that describes a monitor config. Use this if you want\n * to create a monitor automatically when sending a check in.\n */\nexport function withMonitor<T>(\n  monitorSlug: CheckIn['monitorSlug'],\n  callback: () => T,\n  upsertMonitorConfig?: MonitorConfig,\n): T {\n  const checkInId = captureCheckIn({ monitorSlug, status: 'in_progress' }, upsertMonitorConfig);\n  const now = timestampInSeconds();\n\n  function finishCheckIn(status: FinishedCheckIn['status']): void {\n    captureCheckIn({ monitorSlug, status, checkInId, duration: timestampInSeconds() - now });\n  }\n\n  let maybePromiseResult: T;\n  try {\n    maybePromiseResult = callback();\n  } catch (e) {\n    finishCheckIn('error');\n    throw e;\n  }\n\n  if (isThenable(maybePromiseResult)) {\n    Promise.resolve(maybePromiseResult).then(\n      () => {\n        finishCheckIn('ok');\n      },\n      () => {\n        finishCheckIn('error');\n      },\n    );\n  } else {\n    finishCheckIn('ok');\n  }\n\n  return maybePromiseResult;\n}\n\n/**\n * Call `flush()` on the current client, if there is one. See {@link Client.flush}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue. Omitting this parameter will cause\n * the client to wait until all events are sent before resolving the promise.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nexport async function flush(timeout?: number): Promise<boolean> {\n  const client = getClient();\n  if (client) {\n    return client.flush(timeout);\n  }\n  DEBUG_BUILD && logger.warn('Cannot flush events. No client defined.');\n  return Promise.resolve(false);\n}\n\n/**\n * Call `close()` on the current client, if there is one. See {@link Client.close}.\n *\n * @param timeout Maximum time in ms the client should wait to flush its event queue before shutting down. Omitting this\n * parameter will cause the client to wait until all events are sent before disabling itself.\n * @returns A promise which resolves to `true` if the queue successfully drains before the timeout, or `false` if it\n * doesn't (or if there's no client defined).\n */\nexport async function close(timeout?: number): Promise<boolean> {\n  const client = getClient();\n  if (client) {\n    return client.close(timeout);\n  }\n  DEBUG_BUILD && logger.warn('Cannot flush events and disable SDK. No client defined.');\n  return Promise.resolve(false);\n}\n\n/**\n * This is the getter for lastEventId.\n *\n * @returns The last event id of a captured event.\n */\nexport function lastEventId(): string | undefined {\n  // eslint-disable-next-line deprecation/deprecation\n  return getCurrentHub().lastEventId();\n}\n\n/**\n * Get the currently active client.\n */\nexport function getClient<C extends Client>(): C | undefined {\n  // eslint-disable-next-line deprecation/deprecation\n  return getCurrentHub().getClient<C>();\n}\n\n/**\n * Returns true if Sentry has been properly initialized.\n */\nexport function isInitialized(): boolean {\n  return !!getClient();\n}\n\n/**\n * Get the currently active scope.\n */\nexport function getCurrentScope(): Scope {\n  // eslint-disable-next-line deprecation/deprecation\n  return getCurrentHub().getScope();\n}\n\n/**\n * Start a session on the current isolation scope.\n *\n * @param context (optional) additional properties to be applied to the returned session object\n *\n * @returns the new active session\n */\nexport function startSession(context?: SessionContext): Session {\n  const client = getClient();\n  const isolationScope = getIsolationScope();\n  const currentScope = getCurrentScope();\n\n  const { release, environment = DEFAULT_ENVIRONMENT } = (client && client.getOptions()) || {};\n\n  // Will fetch userAgent if called from browser sdk\n  const { userAgent } = GLOBAL_OBJ.navigator || {};\n\n  const session = makeSession({\n    release,\n    environment,\n    user: currentScope.getUser() || isolationScope.getUser(),\n    ...(userAgent && { userAgent }),\n    ...context,\n  });\n\n  // End existing session if there's one\n  const currentSession = isolationScope.getSession();\n  if (currentSession && currentSession.status === 'ok') {\n    updateSession(currentSession, { status: 'exited' });\n  }\n\n  endSession();\n\n  // Afterwards we set the new session on the scope\n  isolationScope.setSession(session);\n\n  // TODO (v8): Remove this and only use the isolation scope(?).\n  // For v7 though, we can't \"soft-break\" people using getCurrentHub().getScope().setSession()\n  currentScope.setSession(session);\n\n  return session;\n}\n\n/**\n * End the session on the current isolation scope.\n */\nexport function endSession(): void {\n  const isolationScope = getIsolationScope();\n  const currentScope = getCurrentScope();\n\n  const session = currentScope.getSession() || isolationScope.getSession();\n  if (session) {\n    closeSession(session);\n  }\n  _sendSessionUpdate();\n\n  // the session is over; take it off of the scope\n  isolationScope.setSession();\n\n  // TODO (v8): Remove this and only use the isolation scope(?).\n  // For v7 though, we can't \"soft-break\" people using getCurrentHub().getScope().setSession()\n  currentScope.setSession();\n}\n\n/**\n * Sends the current Session on the scope\n */\nfunction _sendSessionUpdate(): void {\n  const isolationScope = getIsolationScope();\n  const currentScope = getCurrentScope();\n  const client = getClient();\n  // TODO (v8): Remove currentScope and only use the isolation scope(?).\n  // For v7 though, we can't \"soft-break\" people using getCurrentHub().getScope().setSession()\n  const session = currentScope.getSession() || isolationScope.getSession();\n  if (session && client && client.captureSession) {\n    client.captureSession(session);\n  }\n}\n\n/**\n * Sends the current session on the scope to Sentry\n *\n * @param end If set the session will be marked as exited and removed from the scope.\n *            Defaults to `false`.\n */\nexport function captureSession(end: boolean = false): void {\n  // both send the update and pull the session from the scope\n  if (end) {\n    endSession();\n    return;\n  }\n\n  // only send the update\n  _sendSessionUpdate();\n}\n","/* eslint-disable max-lines */\nimport { addBreadcrumb, convertIntegrationFnToClass, defineIntegration, getClient } from '@sentry/core';\nimport type {\n  Client,\n  Event as SentryEvent,\n  HandlerDataConsole,\n  HandlerDataDom,\n  HandlerDataFetch,\n  HandlerDataHistory,\n  HandlerDataXhr,\n  Integration,\n  IntegrationClass,\n  IntegrationFn,\n} from '@sentry/types';\nimport type {\n  Breadcrumb,\n  FetchBreadcrumbData,\n  FetchBreadcrumbHint,\n  XhrBreadcrumbData,\n  XhrBreadcrumbHint,\n} from '@sentry/types/build/types/breadcrumb';\nimport {\n  SENTRY_XHR_DATA_KEY,\n  addClickKeypressInstrumentationHandler,\n  addConsoleInstrumentationHandler,\n  addFetchInstrumentationHandler,\n  addHistoryInstrumentationHandler,\n  addXhrInstrumentationHandler,\n  getComponentName,\n  getEventDescription,\n  htmlTreeAsString,\n  logger,\n  parseUrl,\n  safeJoin,\n  severityLevelFromString,\n} from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport { WINDOW } from '../helpers';\n\ninterface BreadcrumbsOptions {\n  console: boolean;\n  dom:\n    | boolean\n    | {\n        serializeAttribute?: string | string[];\n        maxStringLength?: number;\n      };\n  fetch: boolean;\n  history: boolean;\n  sentry: boolean;\n  xhr: boolean;\n}\n\n/** maxStringLength gets capped to prevent 100 breadcrumbs exceeding 1MB event payload size */\nconst MAX_ALLOWED_STRING_LENGTH = 1024;\n\nconst INTEGRATION_NAME = 'Breadcrumbs';\n\nconst _breadcrumbsIntegration = ((options: Partial<BreadcrumbsOptions> = {}) => {\n  const _options = {\n    console: true,\n    dom: true,\n    fetch: true,\n    history: true,\n    sentry: true,\n    xhr: true,\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    // TODO v8: Remove this\n    setupOnce() {}, // eslint-disable-line @typescript-eslint/no-empty-function\n    setup(client) {\n      if (_options.console) {\n        addConsoleInstrumentationHandler(_getConsoleBreadcrumbHandler(client));\n      }\n      if (_options.dom) {\n        addClickKeypressInstrumentationHandler(_getDomBreadcrumbHandler(client, _options.dom));\n      }\n      if (_options.xhr) {\n        addXhrInstrumentationHandler(_getXhrBreadcrumbHandler(client));\n      }\n      if (_options.fetch) {\n        addFetchInstrumentationHandler(_getFetchBreadcrumbHandler(client));\n      }\n      if (_options.history) {\n        addHistoryInstrumentationHandler(_getHistoryBreadcrumbHandler(client));\n      }\n      if (_options.sentry && client.on) {\n        client.on('beforeSendEvent', _getSentryBreadcrumbHandler(client));\n      }\n    },\n  };\n}) satisfies IntegrationFn;\n\nexport const breadcrumbsIntegration = defineIntegration(_breadcrumbsIntegration);\n\n/**\n * Default Breadcrumbs instrumentations\n *\n * @deprecated Use `breadcrumbsIntegration()` instead.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport const Breadcrumbs = convertIntegrationFnToClass(INTEGRATION_NAME, breadcrumbsIntegration) as IntegrationClass<\n  Integration & { setup: (client: Client) => void }\n> & {\n  new (\n    options?: Partial<{\n      console: boolean;\n      dom:\n        | boolean\n        | {\n            serializeAttribute?: string | string[];\n            maxStringLength?: number;\n          };\n      fetch: boolean;\n      history: boolean;\n      sentry: boolean;\n      xhr: boolean;\n    }>,\n  ): Integration;\n};\n\n/**\n * Adds a breadcrumb for Sentry events or transactions if this option is enabled.\n */\nfunction _getSentryBreadcrumbHandler(client: Client): (event: SentryEvent) => void {\n  return function addSentryBreadcrumb(event: SentryEvent): void {\n    if (getClient() !== client) {\n      return;\n    }\n\n    addBreadcrumb(\n      {\n        category: `sentry.${event.type === 'transaction' ? 'transaction' : 'event'}`,\n        event_id: event.event_id,\n        level: event.level,\n        message: getEventDescription(event),\n      },\n      {\n        event,\n      },\n    );\n  };\n}\n\n/**\n * A HOC that creaes a function that creates breadcrumbs from DOM API calls.\n * This is a HOC so that we get access to dom options in the closure.\n */\nfunction _getDomBreadcrumbHandler(\n  client: Client,\n  dom: BreadcrumbsOptions['dom'],\n): (handlerData: HandlerDataDom) => void {\n  return function _innerDomBreadcrumb(handlerData: HandlerDataDom): void {\n    if (getClient() !== client) {\n      return;\n    }\n\n    let target;\n    let componentName;\n    let keyAttrs = typeof dom === 'object' ? dom.serializeAttribute : undefined;\n\n    let maxStringLength =\n      typeof dom === 'object' && typeof dom.maxStringLength === 'number' ? dom.maxStringLength : undefined;\n    if (maxStringLength && maxStringLength > MAX_ALLOWED_STRING_LENGTH) {\n      DEBUG_BUILD &&\n        logger.warn(\n          `\\`dom.maxStringLength\\` cannot exceed ${MAX_ALLOWED_STRING_LENGTH}, but a value of ${maxStringLength} was configured. Sentry will use ${MAX_ALLOWED_STRING_LENGTH} instead.`,\n        );\n      maxStringLength = MAX_ALLOWED_STRING_LENGTH;\n    }\n\n    if (typeof keyAttrs === 'string') {\n      keyAttrs = [keyAttrs];\n    }\n\n    // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n    try {\n      const event = handlerData.event as Event | Node;\n      const element = _isEvent(event) ? event.target : event;\n\n      target = htmlTreeAsString(element, { keyAttrs, maxStringLength });\n      componentName = getComponentName(element);\n    } catch (e) {\n      target = '<unknown>';\n    }\n\n    if (target.length === 0) {\n      return;\n    }\n\n    const breadcrumb: Breadcrumb = {\n      category: `ui.${handlerData.name}`,\n      message: target,\n    };\n\n    if (componentName) {\n      breadcrumb.data = { 'ui.component_name': componentName };\n    }\n\n    addBreadcrumb(breadcrumb, {\n      event: handlerData.event,\n      name: handlerData.name,\n      global: handlerData.global,\n    });\n  };\n}\n\n/**\n * Creates breadcrumbs from console API calls\n */\nfunction _getConsoleBreadcrumbHandler(client: Client): (handlerData: HandlerDataConsole) => void {\n  return function _consoleBreadcrumb(handlerData: HandlerDataConsole): void {\n    if (getClient() !== client) {\n      return;\n    }\n\n    const breadcrumb = {\n      category: 'console',\n      data: {\n        arguments: handlerData.args,\n        logger: 'console',\n      },\n      level: severityLevelFromString(handlerData.level),\n      message: safeJoin(handlerData.args, ' '),\n    };\n\n    if (handlerData.level === 'assert') {\n      if (handlerData.args[0] === false) {\n        breadcrumb.message = `Assertion failed: ${safeJoin(handlerData.args.slice(1), ' ') || 'console.assert'}`;\n        breadcrumb.data.arguments = handlerData.args.slice(1);\n      } else {\n        // Don't capture a breadcrumb for passed assertions\n        return;\n      }\n    }\n\n    addBreadcrumb(breadcrumb, {\n      input: handlerData.args,\n      level: handlerData.level,\n    });\n  };\n}\n\n/**\n * Creates breadcrumbs from XHR API calls\n */\nfunction _getXhrBreadcrumbHandler(client: Client): (handlerData: HandlerDataXhr) => void {\n  return function _xhrBreadcrumb(handlerData: HandlerDataXhr): void {\n    if (getClient() !== client) {\n      return;\n    }\n\n    const { startTimestamp, endTimestamp } = handlerData;\n\n    const sentryXhrData = handlerData.xhr[SENTRY_XHR_DATA_KEY];\n\n    // We only capture complete, non-sentry requests\n    if (!startTimestamp || !endTimestamp || !sentryXhrData) {\n      return;\n    }\n\n    const { method, url, status_code, body } = sentryXhrData;\n\n    const data: XhrBreadcrumbData = {\n      method,\n      url,\n      status_code,\n    };\n\n    const hint: XhrBreadcrumbHint = {\n      xhr: handlerData.xhr,\n      input: body,\n      startTimestamp,\n      endTimestamp,\n    };\n\n    addBreadcrumb(\n      {\n        category: 'xhr',\n        data,\n        type: 'http',\n      },\n      hint,\n    );\n  };\n}\n\n/**\n * Creates breadcrumbs from fetch API calls\n */\nfunction _getFetchBreadcrumbHandler(client: Client): (handlerData: HandlerDataFetch) => void {\n  return function _fetchBreadcrumb(handlerData: HandlerDataFetch): void {\n    if (getClient() !== client) {\n      return;\n    }\n\n    const { startTimestamp, endTimestamp } = handlerData;\n\n    // We only capture complete fetch requests\n    if (!endTimestamp) {\n      return;\n    }\n\n    if (handlerData.fetchData.url.match(/sentry_key/) && handlerData.fetchData.method === 'POST') {\n      // We will not create breadcrumbs for fetch requests that contain `sentry_key` (internal sentry requests)\n      return;\n    }\n\n    if (handlerData.error) {\n      const data: FetchBreadcrumbData = handlerData.fetchData;\n      const hint: FetchBreadcrumbHint = {\n        data: handlerData.error,\n        input: handlerData.args,\n        startTimestamp,\n        endTimestamp,\n      };\n\n      addBreadcrumb(\n        {\n          category: 'fetch',\n          data,\n          level: 'error',\n          type: 'http',\n        },\n        hint,\n      );\n    } else {\n      const response = handlerData.response as Response | undefined;\n      const data: FetchBreadcrumbData = {\n        ...handlerData.fetchData,\n        status_code: response && response.status,\n      };\n      const hint: FetchBreadcrumbHint = {\n        input: handlerData.args,\n        response,\n        startTimestamp,\n        endTimestamp,\n      };\n      addBreadcrumb(\n        {\n          category: 'fetch',\n          data,\n          type: 'http',\n        },\n        hint,\n      );\n    }\n  };\n}\n\n/**\n * Creates breadcrumbs from history API calls\n */\nfunction _getHistoryBreadcrumbHandler(client: Client): (handlerData: HandlerDataHistory) => void {\n  return function _historyBreadcrumb(handlerData: HandlerDataHistory): void {\n    if (getClient() !== client) {\n      return;\n    }\n\n    let from: string | undefined = handlerData.from;\n    let to: string | undefined = handlerData.to;\n    const parsedLoc = parseUrl(WINDOW.location.href);\n    let parsedFrom = from ? parseUrl(from) : undefined;\n    const parsedTo = parseUrl(to);\n\n    // Initial pushState doesn't provide `from` information\n    if (!parsedFrom || !parsedFrom.path) {\n      parsedFrom = parsedLoc;\n    }\n\n    // Use only the path component of the URL if the URL matches the current\n    // document (almost all the time when using pushState)\n    if (parsedLoc.protocol === parsedTo.protocol && parsedLoc.host === parsedTo.host) {\n      to = parsedTo.relative;\n    }\n    if (parsedLoc.protocol === parsedFrom.protocol && parsedLoc.host === parsedFrom.host) {\n      from = parsedFrom.relative;\n    }\n\n    addBreadcrumb({\n      category: 'navigation',\n      data: {\n        from,\n        to,\n      },\n    });\n  };\n}\n\nfunction _isEvent(event: unknown): event is Event {\n  return !!event && !!(event as Record<string, unknown>).target;\n}\n","import { GLOBAL_OBJ } from '@sentry/utils';\n\n// exporting a separate copy of `WINDOW` rather than exporting the one from `@sentry/browser`\n// prevents the browser package from being bundled in the CDN bundle, and avoids a\n// circular dependency between the browser and replay packages should `@sentry/browser` import\n// from `@sentry/replay` in the future\nexport const WINDOW = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;\n\nexport const REPLAY_SESSION_KEY = 'sentryReplaySession';\nexport const REPLAY_EVENT_NAME = 'replay_event';\nexport const RECORDING_EVENT_NAME = 'replay_recording';\nexport const UNABLE_TO_SEND_REPLAY = 'Unable to send Replay';\n\n// The idle limit for a session after which recording is paused.\nexport const SESSION_IDLE_PAUSE_DURATION = 300_000; // 5 minutes in ms\n\n// The idle limit for a session after which the session expires.\nexport const SESSION_IDLE_EXPIRE_DURATION = 900_000; // 15 minutes in ms\n\n/** Default flush delays */\nexport const DEFAULT_FLUSH_MIN_DELAY = 5_000;\n// XXX: Temp fix for our debounce logic where `maxWait` would never occur if it\n// was the same as `wait`\nexport const DEFAULT_FLUSH_MAX_DELAY = 5_500;\n\n/* How long to wait for error checkouts */\nexport const BUFFER_CHECKOUT_TIME = 60_000;\n\nexport const RETRY_BASE_INTERVAL = 5000;\nexport const RETRY_MAX_COUNT = 3;\n\n/* The max (uncompressed) size in bytes of a network body. Any body larger than this will be truncated. */\nexport const NETWORK_BODY_MAX_SIZE = 150_000;\n\n/* The max size of a single console arg that is captured. Any arg larger than this will be truncated. */\nexport const CONSOLE_ARG_MAX_SIZE = 5_000;\n\n/* Min. time to wait before we consider something a slow click. */\nexport const SLOW_CLICK_THRESHOLD = 3_000;\n/* For scroll actions after a click, we only look for a very short time period to detect programmatic scrolling. */\nexport const SLOW_CLICK_SCROLL_TIMEOUT = 300;\n\n/** When encountering a total segment size exceeding this size, stop the replay (as we cannot properly ingest it). */\nexport const REPLAY_MAX_EVENT_BUFFER_SIZE = 20_000_000; // ~20MB\n\n/** Replays must be min. 5s long before we send them. */\nexport const MIN_REPLAY_DURATION = 4_999;\n/* The max. allowed value that the minReplayDuration can be set to. */\nexport const MIN_REPLAY_DURATION_LIMIT = 15_000;\n\n/** The max. length of a replay. */\nexport const MAX_REPLAY_DURATION = 3_600_000; // 60 minutes in ms;\n\n/** Default attributes to be ignored when `maskAllText` is enabled */\nexport const DEFAULT_IGNORED_ATTRIBUTES = ['title', 'placeholder'];\n","var NodeType;\r\n(function (NodeType) {\r\n    NodeType[NodeType[\"Document\"] = 0] = \"Document\";\r\n    NodeType[NodeType[\"DocumentType\"] = 1] = \"DocumentType\";\r\n    NodeType[NodeType[\"Element\"] = 2] = \"Element\";\r\n    NodeType[NodeType[\"Text\"] = 3] = \"Text\";\r\n    NodeType[NodeType[\"CDATA\"] = 4] = \"CDATA\";\r\n    NodeType[NodeType[\"Comment\"] = 5] = \"Comment\";\r\n})(NodeType || (NodeType = {}));\n\nfunction isElement(n) {\r\n    return n.nodeType === n.ELEMENT_NODE;\r\n}\r\nfunction isShadowRoot(n) {\r\n    const host = n?.host;\r\n    return Boolean(host?.shadowRoot === n);\r\n}\r\nfunction isNativeShadowDom(shadowRoot) {\r\n    return Object.prototype.toString.call(shadowRoot) === '[object ShadowRoot]';\r\n}\r\nfunction fixBrowserCompatibilityIssuesInCSS(cssText) {\r\n    if (cssText.includes(' background-clip: text;') &&\r\n        !cssText.includes(' -webkit-background-clip: text;')) {\r\n        cssText = cssText.replace(' background-clip: text;', ' -webkit-background-clip: text; background-clip: text;');\r\n    }\r\n    return cssText;\r\n}\r\nfunction escapeImportStatement(rule) {\r\n    const { cssText } = rule;\r\n    if (cssText.split('\"').length < 3)\r\n        return cssText;\r\n    const statement = ['@import', `url(${JSON.stringify(rule.href)})`];\r\n    if (rule.layerName === '') {\r\n        statement.push(`layer`);\r\n    }\r\n    else if (rule.layerName) {\r\n        statement.push(`layer(${rule.layerName})`);\r\n    }\r\n    if (rule.supportsText) {\r\n        statement.push(`supports(${rule.supportsText})`);\r\n    }\r\n    if (rule.media.length) {\r\n        statement.push(rule.media.mediaText);\r\n    }\r\n    return statement.join(' ') + ';';\r\n}\r\nfunction stringifyStylesheet(s) {\r\n    try {\r\n        const rules = s.rules || s.cssRules;\r\n        return rules\r\n            ? fixBrowserCompatibilityIssuesInCSS(Array.from(rules, stringifyRule).join(''))\r\n            : null;\r\n    }\r\n    catch (error) {\r\n        return null;\r\n    }\r\n}\r\nfunction stringifyRule(rule) {\r\n    let importStringified;\r\n    if (isCSSImportRule(rule)) {\r\n        try {\r\n            importStringified =\r\n                stringifyStylesheet(rule.styleSheet) ||\r\n                    escapeImportStatement(rule);\r\n        }\r\n        catch (error) {\r\n        }\r\n    }\r\n    else if (isCSSStyleRule(rule) && rule.selectorText.includes(':')) {\r\n        return fixSafariColons(rule.cssText);\r\n    }\r\n    return importStringified || rule.cssText;\r\n}\r\nfunction fixSafariColons(cssStringified) {\r\n    const regex = /(\\[(?:[\\w-]+)[^\\\\])(:(?:[\\w-]+)\\])/gm;\r\n    return cssStringified.replace(regex, '$1\\\\$2');\r\n}\r\nfunction isCSSImportRule(rule) {\r\n    return 'styleSheet' in rule;\r\n}\r\nfunction isCSSStyleRule(rule) {\r\n    return 'selectorText' in rule;\r\n}\r\nclass Mirror {\r\n    constructor() {\r\n        this.idNodeMap = new Map();\r\n        this.nodeMetaMap = new WeakMap();\r\n    }\r\n    getId(n) {\r\n        if (!n)\r\n            return -1;\r\n        const id = this.getMeta(n)?.id;\r\n        return id ?? -1;\r\n    }\r\n    getNode(id) {\r\n        return this.idNodeMap.get(id) || null;\r\n    }\r\n    getIds() {\r\n        return Array.from(this.idNodeMap.keys());\r\n    }\r\n    getMeta(n) {\r\n        return this.nodeMetaMap.get(n) || null;\r\n    }\r\n    removeNodeFromMap(n) {\r\n        const id = this.getId(n);\r\n        this.idNodeMap.delete(id);\r\n        if (n.childNodes) {\r\n            n.childNodes.forEach((childNode) => this.removeNodeFromMap(childNode));\r\n        }\r\n    }\r\n    has(id) {\r\n        return this.idNodeMap.has(id);\r\n    }\r\n    hasNode(node) {\r\n        return this.nodeMetaMap.has(node);\r\n    }\r\n    add(n, meta) {\r\n        const id = meta.id;\r\n        this.idNodeMap.set(id, n);\r\n        this.nodeMetaMap.set(n, meta);\r\n    }\r\n    replace(id, n) {\r\n        const oldNode = this.getNode(id);\r\n        if (oldNode) {\r\n            const meta = this.nodeMetaMap.get(oldNode);\r\n            if (meta)\r\n                this.nodeMetaMap.set(n, meta);\r\n        }\r\n        this.idNodeMap.set(id, n);\r\n    }\r\n    reset() {\r\n        this.idNodeMap = new Map();\r\n        this.nodeMetaMap = new WeakMap();\r\n    }\r\n}\r\nfunction createMirror() {\r\n    return new Mirror();\r\n}\r\nfunction shouldMaskInput({ maskInputOptions, tagName, type, }) {\r\n    if (tagName === 'OPTION') {\r\n        tagName = 'SELECT';\r\n    }\r\n    return Boolean(maskInputOptions[tagName.toLowerCase()] ||\r\n        (type && maskInputOptions[type]) ||\r\n        type === 'password' ||\r\n        (tagName === 'INPUT' && !type && maskInputOptions['text']));\r\n}\r\nfunction maskInputValue({ isMasked, element, value, maskInputFn, }) {\r\n    let text = value || '';\r\n    if (!isMasked) {\r\n        return text;\r\n    }\r\n    if (maskInputFn) {\r\n        text = maskInputFn(text, element);\r\n    }\r\n    return '*'.repeat(text.length);\r\n}\r\nfunction toLowerCase(str) {\r\n    return str.toLowerCase();\r\n}\r\nfunction toUpperCase(str) {\r\n    return str.toUpperCase();\r\n}\r\nconst ORIGINAL_ATTRIBUTE_NAME = '__rrweb_original__';\r\nfunction is2DCanvasBlank(canvas) {\r\n    const ctx = canvas.getContext('2d');\r\n    if (!ctx)\r\n        return true;\r\n    const chunkSize = 50;\r\n    for (let x = 0; x < canvas.width; x += chunkSize) {\r\n        for (let y = 0; y < canvas.height; y += chunkSize) {\r\n            const getImageData = ctx.getImageData;\r\n            const originalGetImageData = ORIGINAL_ATTRIBUTE_NAME in getImageData\r\n                ? getImageData[ORIGINAL_ATTRIBUTE_NAME]\r\n                : getImageData;\r\n            const pixelBuffer = new Uint32Array(originalGetImageData.call(ctx, x, y, Math.min(chunkSize, canvas.width - x), Math.min(chunkSize, canvas.height - y)).data.buffer);\r\n            if (pixelBuffer.some((pixel) => pixel !== 0))\r\n                return false;\r\n        }\r\n    }\r\n    return true;\r\n}\r\nfunction isNodeMetaEqual(a, b) {\r\n    if (!a || !b || a.type !== b.type)\r\n        return false;\r\n    if (a.type === NodeType.Document)\r\n        return a.compatMode === b.compatMode;\r\n    else if (a.type === NodeType.DocumentType)\r\n        return (a.name === b.name &&\r\n            a.publicId === b.publicId &&\r\n            a.systemId === b.systemId);\r\n    else if (a.type === NodeType.Comment ||\r\n        a.type === NodeType.Text ||\r\n        a.type === NodeType.CDATA)\r\n        return a.textContent === b.textContent;\r\n    else if (a.type === NodeType.Element)\r\n        return (a.tagName === b.tagName &&\r\n            JSON.stringify(a.attributes) ===\r\n                JSON.stringify(b.attributes) &&\r\n            a.isSVG === b.isSVG &&\r\n            a.needBlock === b.needBlock);\r\n    return false;\r\n}\r\nfunction getInputType(element) {\r\n    const type = element.type;\r\n    return element.hasAttribute('data-rr-is-password')\r\n        ? 'password'\r\n        : type\r\n            ?\r\n                toLowerCase(type)\r\n            : null;\r\n}\r\nfunction getInputValue(el, tagName, type) {\r\n    if (tagName === 'INPUT' && (type === 'radio' || type === 'checkbox')) {\r\n        return el.getAttribute('value') || '';\r\n    }\r\n    return el.value;\r\n}\n\nlet _id = 1;\r\nconst tagNameRegex = new RegExp('[^a-z0-9-_:]');\r\nconst IGNORED_NODE = -2;\r\nfunction genId() {\r\n    return _id++;\r\n}\r\nfunction getValidTagName(element) {\r\n    if (element instanceof HTMLFormElement) {\r\n        return 'form';\r\n    }\r\n    const processedTagName = toLowerCase(element.tagName);\r\n    if (tagNameRegex.test(processedTagName)) {\r\n        return 'div';\r\n    }\r\n    return processedTagName;\r\n}\r\nfunction extractOrigin(url) {\r\n    let origin = '';\r\n    if (url.indexOf('//') > -1) {\r\n        origin = url.split('/').slice(0, 3).join('/');\r\n    }\r\n    else {\r\n        origin = url.split('/')[0];\r\n    }\r\n    origin = origin.split('?')[0];\r\n    return origin;\r\n}\r\nlet canvasService;\r\nlet canvasCtx;\r\nconst URL_IN_CSS_REF = /url\\((?:(')([^']*)'|(\")(.*?)\"|([^)]*))\\)/gm;\r\nconst URL_PROTOCOL_MATCH = /^(?:[a-z+]+:)?\\/\\//i;\r\nconst URL_WWW_MATCH = /^www\\..*/i;\r\nconst DATA_URI = /^(data:)([^,]*),(.*)/i;\r\nfunction absoluteToStylesheet(cssText, href) {\r\n    return (cssText || '').replace(URL_IN_CSS_REF, (origin, quote1, path1, quote2, path2, path3) => {\r\n        const filePath = path1 || path2 || path3;\r\n        const maybeQuote = quote1 || quote2 || '';\r\n        if (!filePath) {\r\n            return origin;\r\n        }\r\n        if (URL_PROTOCOL_MATCH.test(filePath) || URL_WWW_MATCH.test(filePath)) {\r\n            return `url(${maybeQuote}${filePath}${maybeQuote})`;\r\n        }\r\n        if (DATA_URI.test(filePath)) {\r\n            return `url(${maybeQuote}${filePath}${maybeQuote})`;\r\n        }\r\n        if (filePath[0] === '/') {\r\n            return `url(${maybeQuote}${extractOrigin(href) + filePath}${maybeQuote})`;\r\n        }\r\n        const stack = href.split('/');\r\n        const parts = filePath.split('/');\r\n        stack.pop();\r\n        for (const part of parts) {\r\n            if (part === '.') {\r\n                continue;\r\n            }\r\n            else if (part === '..') {\r\n                stack.pop();\r\n            }\r\n            else {\r\n                stack.push(part);\r\n            }\r\n        }\r\n        return `url(${maybeQuote}${stack.join('/')}${maybeQuote})`;\r\n    });\r\n}\r\nconst SRCSET_NOT_SPACES = /^[^ \\t\\n\\r\\u000c]+/;\r\nconst SRCSET_COMMAS_OR_SPACES = /^[, \\t\\n\\r\\u000c]+/;\r\nfunction getAbsoluteSrcsetString(doc, attributeValue) {\r\n    if (attributeValue.trim() === '') {\r\n        return attributeValue;\r\n    }\r\n    let pos = 0;\r\n    function collectCharacters(regEx) {\r\n        let chars;\r\n        const match = regEx.exec(attributeValue.substring(pos));\r\n        if (match) {\r\n            chars = match[0];\r\n            pos += chars.length;\r\n            return chars;\r\n        }\r\n        return '';\r\n    }\r\n    const output = [];\r\n    while (true) {\r\n        collectCharacters(SRCSET_COMMAS_OR_SPACES);\r\n        if (pos >= attributeValue.length) {\r\n            break;\r\n        }\r\n        let url = collectCharacters(SRCSET_NOT_SPACES);\r\n        if (url.slice(-1) === ',') {\r\n            url = absoluteToDoc(doc, url.substring(0, url.length - 1));\r\n            output.push(url);\r\n        }\r\n        else {\r\n            let descriptorsStr = '';\r\n            url = absoluteToDoc(doc, url);\r\n            let inParens = false;\r\n            while (true) {\r\n                const c = attributeValue.charAt(pos);\r\n                if (c === '') {\r\n                    output.push((url + descriptorsStr).trim());\r\n                    break;\r\n                }\r\n                else if (!inParens) {\r\n                    if (c === ',') {\r\n                        pos += 1;\r\n                        output.push((url + descriptorsStr).trim());\r\n                        break;\r\n                    }\r\n                    else if (c === '(') {\r\n                        inParens = true;\r\n                    }\r\n                }\r\n                else {\r\n                    if (c === ')') {\r\n                        inParens = false;\r\n                    }\r\n                }\r\n                descriptorsStr += c;\r\n                pos += 1;\r\n            }\r\n        }\r\n    }\r\n    return output.join(', ');\r\n}\r\nfunction absoluteToDoc(doc, attributeValue) {\r\n    if (!attributeValue || attributeValue.trim() === '') {\r\n        return attributeValue;\r\n    }\r\n    const a = doc.createElement('a');\r\n    a.href = attributeValue;\r\n    return a.href;\r\n}\r\nfunction isSVGElement(el) {\r\n    return Boolean(el.tagName === 'svg' || el.ownerSVGElement);\r\n}\r\nfunction getHref() {\r\n    const a = document.createElement('a');\r\n    a.href = '';\r\n    return a.href;\r\n}\r\nfunction transformAttribute(doc, tagName, name, value, element, maskAttributeFn) {\r\n    if (!value) {\r\n        return value;\r\n    }\r\n    if (name === 'src' ||\r\n        (name === 'href' && !(tagName === 'use' && value[0] === '#'))) {\r\n        return absoluteToDoc(doc, value);\r\n    }\r\n    else if (name === 'xlink:href' && value[0] !== '#') {\r\n        return absoluteToDoc(doc, value);\r\n    }\r\n    else if (name === 'background' &&\r\n        (tagName === 'table' || tagName === 'td' || tagName === 'th')) {\r\n        return absoluteToDoc(doc, value);\r\n    }\r\n    else if (name === 'srcset') {\r\n        return getAbsoluteSrcsetString(doc, value);\r\n    }\r\n    else if (name === 'style') {\r\n        return absoluteToStylesheet(value, getHref());\r\n    }\r\n    else if (tagName === 'object' && name === 'data') {\r\n        return absoluteToDoc(doc, value);\r\n    }\r\n    if (typeof maskAttributeFn === 'function') {\r\n        return maskAttributeFn(name, value, element);\r\n    }\r\n    return value;\r\n}\r\nfunction ignoreAttribute(tagName, name, _value) {\r\n    return (tagName === 'video' || tagName === 'audio') && name === 'autoplay';\r\n}\r\nfunction _isBlockedElement(element, blockClass, blockSelector, unblockSelector) {\r\n    try {\r\n        if (unblockSelector && element.matches(unblockSelector)) {\r\n            return false;\r\n        }\r\n        if (typeof blockClass === 'string') {\r\n            if (element.classList.contains(blockClass)) {\r\n                return true;\r\n            }\r\n        }\r\n        else {\r\n            for (let eIndex = element.classList.length; eIndex--;) {\r\n                const className = element.classList[eIndex];\r\n                if (blockClass.test(className)) {\r\n                    return true;\r\n                }\r\n            }\r\n        }\r\n        if (blockSelector) {\r\n            return element.matches(blockSelector);\r\n        }\r\n    }\r\n    catch (e) {\r\n    }\r\n    return false;\r\n}\r\nfunction elementClassMatchesRegex(el, regex) {\r\n    for (let eIndex = el.classList.length; eIndex--;) {\r\n        const className = el.classList[eIndex];\r\n        if (regex.test(className)) {\r\n            return true;\r\n        }\r\n    }\r\n    return false;\r\n}\r\nfunction distanceToMatch(node, matchPredicate, limit = Infinity, distance = 0) {\r\n    if (!node)\r\n        return -1;\r\n    if (node.nodeType !== node.ELEMENT_NODE)\r\n        return -1;\r\n    if (distance > limit)\r\n        return -1;\r\n    if (matchPredicate(node))\r\n        return distance;\r\n    return distanceToMatch(node.parentNode, matchPredicate, limit, distance + 1);\r\n}\r\nfunction createMatchPredicate(className, selector) {\r\n    return (node) => {\r\n        const el = node;\r\n        if (el === null)\r\n            return false;\r\n        try {\r\n            if (className) {\r\n                if (typeof className === 'string') {\r\n                    if (el.matches(`.${className}`))\r\n                        return true;\r\n                }\r\n                else if (elementClassMatchesRegex(el, className)) {\r\n                    return true;\r\n                }\r\n            }\r\n            if (selector && el.matches(selector))\r\n                return true;\r\n            return false;\r\n        }\r\n        catch {\r\n            return false;\r\n        }\r\n    };\r\n}\r\nfunction needMaskingText(node, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, maskAllText) {\r\n    try {\r\n        const el = node.nodeType === node.ELEMENT_NODE\r\n            ? node\r\n            : node.parentElement;\r\n        if (el === null)\r\n            return false;\r\n        if (el.tagName === 'INPUT') {\r\n            const autocomplete = el.getAttribute('autocomplete');\r\n            const disallowedAutocompleteValues = [\r\n                'current-password',\r\n                'new-password',\r\n                'cc-number',\r\n                'cc-exp',\r\n                'cc-exp-month',\r\n                'cc-exp-year',\r\n                'cc-csc',\r\n            ];\r\n            if (disallowedAutocompleteValues.includes(autocomplete)) {\r\n                return true;\r\n            }\r\n        }\r\n        let maskDistance = -1;\r\n        let unmaskDistance = -1;\r\n        if (maskAllText) {\r\n            unmaskDistance = distanceToMatch(el, createMatchPredicate(unmaskTextClass, unmaskTextSelector));\r\n            if (unmaskDistance < 0) {\r\n                return true;\r\n            }\r\n            maskDistance = distanceToMatch(el, createMatchPredicate(maskTextClass, maskTextSelector), unmaskDistance >= 0 ? unmaskDistance : Infinity);\r\n        }\r\n        else {\r\n            maskDistance = distanceToMatch(el, createMatchPredicate(maskTextClass, maskTextSelector));\r\n            if (maskDistance < 0) {\r\n                return false;\r\n            }\r\n            unmaskDistance = distanceToMatch(el, createMatchPredicate(unmaskTextClass, unmaskTextSelector), maskDistance >= 0 ? maskDistance : Infinity);\r\n        }\r\n        return maskDistance >= 0\r\n            ? unmaskDistance >= 0\r\n                ? maskDistance <= unmaskDistance\r\n                : true\r\n            : unmaskDistance >= 0\r\n                ? false\r\n                : !!maskAllText;\r\n    }\r\n    catch (e) {\r\n    }\r\n    return !!maskAllText;\r\n}\r\nfunction onceIframeLoaded(iframeEl, listener, iframeLoadTimeout) {\r\n    const win = iframeEl.contentWindow;\r\n    if (!win) {\r\n        return;\r\n    }\r\n    let fired = false;\r\n    let readyState;\r\n    try {\r\n        readyState = win.document.readyState;\r\n    }\r\n    catch (error) {\r\n        return;\r\n    }\r\n    if (readyState !== 'complete') {\r\n        const timer = setTimeout(() => {\r\n            if (!fired) {\r\n                listener();\r\n                fired = true;\r\n            }\r\n        }, iframeLoadTimeout);\r\n        iframeEl.addEventListener('load', () => {\r\n            clearTimeout(timer);\r\n            fired = true;\r\n            listener();\r\n        });\r\n        return;\r\n    }\r\n    const blankUrl = 'about:blank';\r\n    if (win.location.href !== blankUrl ||\r\n        iframeEl.src === blankUrl ||\r\n        iframeEl.src === '') {\r\n        setTimeout(listener, 0);\r\n        return iframeEl.addEventListener('load', listener);\r\n    }\r\n    iframeEl.addEventListener('load', listener);\r\n}\r\nfunction onceStylesheetLoaded(link, listener, styleSheetLoadTimeout) {\r\n    let fired = false;\r\n    let styleSheetLoaded;\r\n    try {\r\n        styleSheetLoaded = link.sheet;\r\n    }\r\n    catch (error) {\r\n        return;\r\n    }\r\n    if (styleSheetLoaded)\r\n        return;\r\n    const timer = setTimeout(() => {\r\n        if (!fired) {\r\n            listener();\r\n            fired = true;\r\n        }\r\n    }, styleSheetLoadTimeout);\r\n    link.addEventListener('load', () => {\r\n        clearTimeout(timer);\r\n        fired = true;\r\n        listener();\r\n    });\r\n}\r\nfunction serializeNode(n, options) {\r\n    const { doc, mirror, blockClass, blockSelector, unblockSelector, maskAllText, maskAttributeFn, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, inlineStylesheet, maskInputOptions = {}, maskTextFn, maskInputFn, dataURLOptions = {}, inlineImages, recordCanvas, keepIframeSrcFn, newlyAddedElement = false, } = options;\r\n    const rootId = getRootId(doc, mirror);\r\n    switch (n.nodeType) {\r\n        case n.DOCUMENT_NODE:\r\n            if (n.compatMode !== 'CSS1Compat') {\r\n                return {\r\n                    type: NodeType.Document,\r\n                    childNodes: [],\r\n                    compatMode: n.compatMode,\r\n                };\r\n            }\r\n            else {\r\n                return {\r\n                    type: NodeType.Document,\r\n                    childNodes: [],\r\n                };\r\n            }\r\n        case n.DOCUMENT_TYPE_NODE:\r\n            return {\r\n                type: NodeType.DocumentType,\r\n                name: n.name,\r\n                publicId: n.publicId,\r\n                systemId: n.systemId,\r\n                rootId,\r\n            };\r\n        case n.ELEMENT_NODE:\r\n            return serializeElementNode(n, {\r\n                doc,\r\n                blockClass,\r\n                blockSelector,\r\n                unblockSelector,\r\n                inlineStylesheet,\r\n                maskAttributeFn,\r\n                maskInputOptions,\r\n                maskInputFn,\r\n                dataURLOptions,\r\n                inlineImages,\r\n                recordCanvas,\r\n                keepIframeSrcFn,\r\n                newlyAddedElement,\r\n                rootId,\r\n                maskAllText,\r\n                maskTextClass,\r\n                unmaskTextClass,\r\n                maskTextSelector,\r\n                unmaskTextSelector,\r\n            });\r\n        case n.TEXT_NODE:\r\n            return serializeTextNode(n, {\r\n                maskAllText,\r\n                maskTextClass,\r\n                unmaskTextClass,\r\n                maskTextSelector,\r\n                unmaskTextSelector,\r\n                maskTextFn,\r\n                maskInputOptions,\r\n                maskInputFn,\r\n                rootId,\r\n            });\r\n        case n.CDATA_SECTION_NODE:\r\n            return {\r\n                type: NodeType.CDATA,\r\n                textContent: '',\r\n                rootId,\r\n            };\r\n        case n.COMMENT_NODE:\r\n            return {\r\n                type: NodeType.Comment,\r\n                textContent: n.textContent || '',\r\n                rootId,\r\n            };\r\n        default:\r\n            return false;\r\n    }\r\n}\r\nfunction getRootId(doc, mirror) {\r\n    if (!mirror.hasNode(doc))\r\n        return undefined;\r\n    const docId = mirror.getId(doc);\r\n    return docId === 1 ? undefined : docId;\r\n}\r\nfunction serializeTextNode(n, options) {\r\n    const { maskAllText, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, maskTextFn, maskInputOptions, maskInputFn, rootId, } = options;\r\n    const parentTagName = n.parentNode && n.parentNode.tagName;\r\n    let textContent = n.textContent;\r\n    const isStyle = parentTagName === 'STYLE' ? true : undefined;\r\n    const isScript = parentTagName === 'SCRIPT' ? true : undefined;\r\n    const isTextarea = parentTagName === 'TEXTAREA' ? true : undefined;\r\n    if (isStyle && textContent) {\r\n        try {\r\n            if (n.nextSibling || n.previousSibling) {\r\n            }\r\n            else if (n.parentNode.sheet?.cssRules) {\r\n                textContent = stringifyStylesheet(n.parentNode.sheet);\r\n            }\r\n        }\r\n        catch (err) {\r\n            console.warn(`Cannot get CSS styles from text's parentNode. Error: ${err}`, n);\r\n        }\r\n        textContent = absoluteToStylesheet(textContent, getHref());\r\n    }\r\n    if (isScript) {\r\n        textContent = 'SCRIPT_PLACEHOLDER';\r\n    }\r\n    const forceMask = needMaskingText(n, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, maskAllText);\r\n    if (!isStyle && !isScript && !isTextarea && textContent && forceMask) {\r\n        textContent = maskTextFn\r\n            ? maskTextFn(textContent, n.parentElement)\r\n            : textContent.replace(/[\\S]/g, '*');\r\n    }\r\n    if (isTextarea && textContent && (maskInputOptions.textarea || forceMask)) {\r\n        textContent = maskInputFn\r\n            ? maskInputFn(textContent, n.parentNode)\r\n            : textContent.replace(/[\\S]/g, '*');\r\n    }\r\n    if (parentTagName === 'OPTION' && textContent) {\r\n        const isInputMasked = shouldMaskInput({\r\n            type: null,\r\n            tagName: parentTagName,\r\n            maskInputOptions,\r\n        });\r\n        textContent = maskInputValue({\r\n            isMasked: needMaskingText(n, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, isInputMasked),\r\n            element: n,\r\n            value: textContent,\r\n            maskInputFn,\r\n        });\r\n    }\r\n    return {\r\n        type: NodeType.Text,\r\n        textContent: textContent || '',\r\n        isStyle,\r\n        rootId,\r\n    };\r\n}\r\nfunction serializeElementNode(n, options) {\r\n    const { doc, blockClass, blockSelector, unblockSelector, inlineStylesheet, maskInputOptions = {}, maskAttributeFn, maskInputFn, dataURLOptions = {}, inlineImages, recordCanvas, keepIframeSrcFn, newlyAddedElement = false, rootId, maskAllText, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, } = options;\r\n    const needBlock = _isBlockedElement(n, blockClass, blockSelector, unblockSelector);\r\n    const tagName = getValidTagName(n);\r\n    let attributes = {};\r\n    const len = n.attributes.length;\r\n    for (let i = 0; i < len; i++) {\r\n        const attr = n.attributes[i];\r\n        if (attr.name && !ignoreAttribute(tagName, attr.name, attr.value)) {\r\n            attributes[attr.name] = transformAttribute(doc, tagName, toLowerCase(attr.name), attr.value, n, maskAttributeFn);\r\n        }\r\n    }\r\n    if (tagName === 'link' && inlineStylesheet) {\r\n        const stylesheet = Array.from(doc.styleSheets).find((s) => {\r\n            return s.href === n.href;\r\n        });\r\n        let cssText = null;\r\n        if (stylesheet) {\r\n            cssText = stringifyStylesheet(stylesheet);\r\n        }\r\n        if (cssText) {\r\n            delete attributes.rel;\r\n            delete attributes.href;\r\n            attributes._cssText = absoluteToStylesheet(cssText, stylesheet.href);\r\n        }\r\n    }\r\n    if (tagName === 'style' &&\r\n        n.sheet &&\r\n        !(n.innerText || n.textContent || '').trim().length) {\r\n        const cssText = stringifyStylesheet(n.sheet);\r\n        if (cssText) {\r\n            attributes._cssText = absoluteToStylesheet(cssText, getHref());\r\n        }\r\n    }\r\n    if (tagName === 'input' ||\r\n        tagName === 'textarea' ||\r\n        tagName === 'select' ||\r\n        tagName === 'option') {\r\n        const el = n;\r\n        const type = getInputType(el);\r\n        const value = getInputValue(el, toUpperCase(tagName), type);\r\n        const checked = el.checked;\r\n        if (type !== 'submit' && type !== 'button' && value) {\r\n            const forceMask = needMaskingText(el, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, shouldMaskInput({\r\n                type,\r\n                tagName: toUpperCase(tagName),\r\n                maskInputOptions,\r\n            }));\r\n            attributes.value = maskInputValue({\r\n                isMasked: forceMask,\r\n                element: el,\r\n                value,\r\n                maskInputFn,\r\n            });\r\n        }\r\n        if (checked) {\r\n            attributes.checked = checked;\r\n        }\r\n    }\r\n    if (tagName === 'option') {\r\n        if (n.selected && !maskInputOptions['select']) {\r\n            attributes.selected = true;\r\n        }\r\n        else {\r\n            delete attributes.selected;\r\n        }\r\n    }\r\n    if (tagName === 'canvas' && recordCanvas) {\r\n        if (n.__context === '2d') {\r\n            if (!is2DCanvasBlank(n)) {\r\n                attributes.rr_dataURL = n.toDataURL(dataURLOptions.type, dataURLOptions.quality);\r\n            }\r\n        }\r\n        else if (!('__context' in n)) {\r\n            const canvasDataURL = n.toDataURL(dataURLOptions.type, dataURLOptions.quality);\r\n            const blankCanvas = document.createElement('canvas');\r\n            blankCanvas.width = n.width;\r\n            blankCanvas.height = n.height;\r\n            const blankCanvasDataURL = blankCanvas.toDataURL(dataURLOptions.type, dataURLOptions.quality);\r\n            if (canvasDataURL !== blankCanvasDataURL) {\r\n                attributes.rr_dataURL = canvasDataURL;\r\n            }\r\n        }\r\n    }\r\n    if (tagName === 'img' && inlineImages) {\r\n        if (!canvasService) {\r\n            canvasService = doc.createElement('canvas');\r\n            canvasCtx = canvasService.getContext('2d');\r\n        }\r\n        const image = n;\r\n        const oldValue = image.crossOrigin;\r\n        image.crossOrigin = 'anonymous';\r\n        const recordInlineImage = () => {\r\n            image.removeEventListener('load', recordInlineImage);\r\n            try {\r\n                canvasService.width = image.naturalWidth;\r\n                canvasService.height = image.naturalHeight;\r\n                canvasCtx.drawImage(image, 0, 0);\r\n                attributes.rr_dataURL = canvasService.toDataURL(dataURLOptions.type, dataURLOptions.quality);\r\n            }\r\n            catch (err) {\r\n                console.warn(`Cannot inline img src=${image.currentSrc}! Error: ${err}`);\r\n            }\r\n            oldValue\r\n                ? (attributes.crossOrigin = oldValue)\r\n                : image.removeAttribute('crossorigin');\r\n        };\r\n        if (image.complete && image.naturalWidth !== 0)\r\n            recordInlineImage();\r\n        else\r\n            image.addEventListener('load', recordInlineImage);\r\n    }\r\n    if (tagName === 'audio' || tagName === 'video') {\r\n        attributes.rr_mediaState = n.paused\r\n            ? 'paused'\r\n            : 'played';\r\n        attributes.rr_mediaCurrentTime = n.currentTime;\r\n    }\r\n    if (!newlyAddedElement) {\r\n        if (n.scrollLeft) {\r\n            attributes.rr_scrollLeft = n.scrollLeft;\r\n        }\r\n        if (n.scrollTop) {\r\n            attributes.rr_scrollTop = n.scrollTop;\r\n        }\r\n    }\r\n    if (needBlock) {\r\n        const { width, height } = n.getBoundingClientRect();\r\n        attributes = {\r\n            class: attributes.class,\r\n            rr_width: `${width}px`,\r\n            rr_height: `${height}px`,\r\n        };\r\n    }\r\n    if (tagName === 'iframe' && !keepIframeSrcFn(attributes.src)) {\r\n        if (!n.contentDocument) {\r\n            attributes.rr_src = attributes.src;\r\n        }\r\n        delete attributes.src;\r\n    }\r\n    let isCustomElement;\r\n    try {\r\n        if (customElements.get(tagName))\r\n            isCustomElement = true;\r\n    }\r\n    catch (e) {\r\n    }\r\n    return {\r\n        type: NodeType.Element,\r\n        tagName,\r\n        attributes,\r\n        childNodes: [],\r\n        isSVG: isSVGElement(n) || undefined,\r\n        needBlock,\r\n        rootId,\r\n        isCustom: isCustomElement,\r\n    };\r\n}\r\nfunction lowerIfExists(maybeAttr) {\r\n    if (maybeAttr === undefined || maybeAttr === null) {\r\n        return '';\r\n    }\r\n    else {\r\n        return maybeAttr.toLowerCase();\r\n    }\r\n}\r\nfunction slimDOMExcluded(sn, slimDOMOptions) {\r\n    if (slimDOMOptions.comment && sn.type === NodeType.Comment) {\r\n        return true;\r\n    }\r\n    else if (sn.type === NodeType.Element) {\r\n        if (slimDOMOptions.script &&\r\n            (sn.tagName === 'script' ||\r\n                (sn.tagName === 'link' &&\r\n                    (sn.attributes.rel === 'preload' ||\r\n                        sn.attributes.rel === 'modulepreload') &&\r\n                    sn.attributes.as === 'script') ||\r\n                (sn.tagName === 'link' &&\r\n                    sn.attributes.rel === 'prefetch' &&\r\n                    typeof sn.attributes.href === 'string' &&\r\n                    sn.attributes.href.endsWith('.js')))) {\r\n            return true;\r\n        }\r\n        else if (slimDOMOptions.headFavicon &&\r\n            ((sn.tagName === 'link' && sn.attributes.rel === 'shortcut icon') ||\r\n                (sn.tagName === 'meta' &&\r\n                    (lowerIfExists(sn.attributes.name).match(/^msapplication-tile(image|color)$/) ||\r\n                        lowerIfExists(sn.attributes.name) === 'application-name' ||\r\n                        lowerIfExists(sn.attributes.rel) === 'icon' ||\r\n                        lowerIfExists(sn.attributes.rel) === 'apple-touch-icon' ||\r\n                        lowerIfExists(sn.attributes.rel) === 'shortcut icon')))) {\r\n            return true;\r\n        }\r\n        else if (sn.tagName === 'meta') {\r\n            if (slimDOMOptions.headMetaDescKeywords &&\r\n                lowerIfExists(sn.attributes.name).match(/^description|keywords$/)) {\r\n                return true;\r\n            }\r\n            else if (slimDOMOptions.headMetaSocial &&\r\n                (lowerIfExists(sn.attributes.property).match(/^(og|twitter|fb):/) ||\r\n                    lowerIfExists(sn.attributes.name).match(/^(og|twitter):/) ||\r\n                    lowerIfExists(sn.attributes.name) === 'pinterest')) {\r\n                return true;\r\n            }\r\n            else if (slimDOMOptions.headMetaRobots &&\r\n                (lowerIfExists(sn.attributes.name) === 'robots' ||\r\n                    lowerIfExists(sn.attributes.name) === 'googlebot' ||\r\n                    lowerIfExists(sn.attributes.name) === 'bingbot')) {\r\n                return true;\r\n            }\r\n            else if (slimDOMOptions.headMetaHttpEquiv &&\r\n                sn.attributes['http-equiv'] !== undefined) {\r\n                return true;\r\n            }\r\n            else if (slimDOMOptions.headMetaAuthorship &&\r\n                (lowerIfExists(sn.attributes.name) === 'author' ||\r\n                    lowerIfExists(sn.attributes.name) === 'generator' ||\r\n                    lowerIfExists(sn.attributes.name) === 'framework' ||\r\n                    lowerIfExists(sn.attributes.name) === 'publisher' ||\r\n                    lowerIfExists(sn.attributes.name) === 'progid' ||\r\n                    lowerIfExists(sn.attributes.property).match(/^article:/) ||\r\n                    lowerIfExists(sn.attributes.property).match(/^product:/))) {\r\n                return true;\r\n            }\r\n            else if (slimDOMOptions.headMetaVerification &&\r\n                (lowerIfExists(sn.attributes.name) === 'google-site-verification' ||\r\n                    lowerIfExists(sn.attributes.name) === 'yandex-verification' ||\r\n                    lowerIfExists(sn.attributes.name) === 'csrf-token' ||\r\n                    lowerIfExists(sn.attributes.name) === 'p:domain_verify' ||\r\n                    lowerIfExists(sn.attributes.name) === 'verify-v1' ||\r\n                    lowerIfExists(sn.attributes.name) === 'verification' ||\r\n                    lowerIfExists(sn.attributes.name) === 'shopify-checkout-api-token')) {\r\n                return true;\r\n            }\r\n        }\r\n    }\r\n    return false;\r\n}\r\nfunction serializeNodeWithId(n, options) {\r\n    const { doc, mirror, blockClass, blockSelector, unblockSelector, maskAllText, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, skipChild = false, inlineStylesheet = true, maskInputOptions = {}, maskAttributeFn, maskTextFn, maskInputFn, slimDOMOptions, dataURLOptions = {}, inlineImages = false, recordCanvas = false, onSerialize, onIframeLoad, iframeLoadTimeout = 5000, onStylesheetLoad, stylesheetLoadTimeout = 5000, keepIframeSrcFn = () => false, newlyAddedElement = false, } = options;\r\n    let { preserveWhiteSpace = true } = options;\r\n    const _serializedNode = serializeNode(n, {\r\n        doc,\r\n        mirror,\r\n        blockClass,\r\n        blockSelector,\r\n        maskAllText,\r\n        unblockSelector,\r\n        maskTextClass,\r\n        unmaskTextClass,\r\n        maskTextSelector,\r\n        unmaskTextSelector,\r\n        inlineStylesheet,\r\n        maskInputOptions,\r\n        maskAttributeFn,\r\n        maskTextFn,\r\n        maskInputFn,\r\n        dataURLOptions,\r\n        inlineImages,\r\n        recordCanvas,\r\n        keepIframeSrcFn,\r\n        newlyAddedElement,\r\n    });\r\n    if (!_serializedNode) {\r\n        console.warn(n, 'not serialized');\r\n        return null;\r\n    }\r\n    let id;\r\n    if (mirror.hasNode(n)) {\r\n        id = mirror.getId(n);\r\n    }\r\n    else if (slimDOMExcluded(_serializedNode, slimDOMOptions) ||\r\n        (!preserveWhiteSpace &&\r\n            _serializedNode.type === NodeType.Text &&\r\n            !_serializedNode.isStyle &&\r\n            !_serializedNode.textContent.replace(/^\\s+|\\s+$/gm, '').length)) {\r\n        id = IGNORED_NODE;\r\n    }\r\n    else {\r\n        id = genId();\r\n    }\r\n    const serializedNode = Object.assign(_serializedNode, { id });\r\n    mirror.add(n, serializedNode);\r\n    if (id === IGNORED_NODE) {\r\n        return null;\r\n    }\r\n    if (onSerialize) {\r\n        onSerialize(n);\r\n    }\r\n    let recordChild = !skipChild;\r\n    if (serializedNode.type === NodeType.Element) {\r\n        recordChild = recordChild && !serializedNode.needBlock;\r\n        delete serializedNode.needBlock;\r\n        const shadowRoot = n.shadowRoot;\r\n        if (shadowRoot && isNativeShadowDom(shadowRoot))\r\n            serializedNode.isShadowHost = true;\r\n    }\r\n    if ((serializedNode.type === NodeType.Document ||\r\n        serializedNode.type === NodeType.Element) &&\r\n        recordChild) {\r\n        if (slimDOMOptions.headWhitespace &&\r\n            serializedNode.type === NodeType.Element &&\r\n            serializedNode.tagName === 'head') {\r\n            preserveWhiteSpace = false;\r\n        }\r\n        const bypassOptions = {\r\n            doc,\r\n            mirror,\r\n            blockClass,\r\n            blockSelector,\r\n            maskAllText,\r\n            unblockSelector,\r\n            maskTextClass,\r\n            unmaskTextClass,\r\n            maskTextSelector,\r\n            unmaskTextSelector,\r\n            skipChild,\r\n            inlineStylesheet,\r\n            maskInputOptions,\r\n            maskAttributeFn,\r\n            maskTextFn,\r\n            maskInputFn,\r\n            slimDOMOptions,\r\n            dataURLOptions,\r\n            inlineImages,\r\n            recordCanvas,\r\n            preserveWhiteSpace,\r\n            onSerialize,\r\n            onIframeLoad,\r\n            iframeLoadTimeout,\r\n            onStylesheetLoad,\r\n            stylesheetLoadTimeout,\r\n            keepIframeSrcFn,\r\n        };\r\n        for (const childN of Array.from(n.childNodes)) {\r\n            const serializedChildNode = serializeNodeWithId(childN, bypassOptions);\r\n            if (serializedChildNode) {\r\n                serializedNode.childNodes.push(serializedChildNode);\r\n            }\r\n        }\r\n        if (isElement(n) && n.shadowRoot) {\r\n            for (const childN of Array.from(n.shadowRoot.childNodes)) {\r\n                const serializedChildNode = serializeNodeWithId(childN, bypassOptions);\r\n                if (serializedChildNode) {\r\n                    isNativeShadowDom(n.shadowRoot) &&\r\n                        (serializedChildNode.isShadow = true);\r\n                    serializedNode.childNodes.push(serializedChildNode);\r\n                }\r\n            }\r\n        }\r\n    }\r\n    if (n.parentNode &&\r\n        isShadowRoot(n.parentNode) &&\r\n        isNativeShadowDom(n.parentNode)) {\r\n        serializedNode.isShadow = true;\r\n    }\r\n    if (serializedNode.type === NodeType.Element &&\r\n        serializedNode.tagName === 'iframe') {\r\n        onceIframeLoaded(n, () => {\r\n            const iframeDoc = n.contentDocument;\r\n            if (iframeDoc && onIframeLoad) {\r\n                const serializedIframeNode = serializeNodeWithId(iframeDoc, {\r\n                    doc: iframeDoc,\r\n                    mirror,\r\n                    blockClass,\r\n                    blockSelector,\r\n                    unblockSelector,\r\n                    maskAllText,\r\n                    maskTextClass,\r\n                    unmaskTextClass,\r\n                    maskTextSelector,\r\n                    unmaskTextSelector,\r\n                    skipChild: false,\r\n                    inlineStylesheet,\r\n                    maskInputOptions,\r\n                    maskAttributeFn,\r\n                    maskTextFn,\r\n                    maskInputFn,\r\n                    slimDOMOptions,\r\n                    dataURLOptions,\r\n                    inlineImages,\r\n                    recordCanvas,\r\n                    preserveWhiteSpace,\r\n                    onSerialize,\r\n                    onIframeLoad,\r\n                    iframeLoadTimeout,\r\n                    onStylesheetLoad,\r\n                    stylesheetLoadTimeout,\r\n                    keepIframeSrcFn,\r\n                });\r\n                if (serializedIframeNode) {\r\n                    onIframeLoad(n, serializedIframeNode);\r\n                }\r\n            }\r\n        }, iframeLoadTimeout);\r\n    }\r\n    if (serializedNode.type === NodeType.Element &&\r\n        serializedNode.tagName === 'link' &&\r\n        serializedNode.attributes.rel === 'stylesheet') {\r\n        onceStylesheetLoaded(n, () => {\r\n            if (onStylesheetLoad) {\r\n                const serializedLinkNode = serializeNodeWithId(n, {\r\n                    doc,\r\n                    mirror,\r\n                    blockClass,\r\n                    blockSelector,\r\n                    unblockSelector,\r\n                    maskAllText,\r\n                    maskTextClass,\r\n                    unmaskTextClass,\r\n                    maskTextSelector,\r\n                    unmaskTextSelector,\r\n                    skipChild: false,\r\n                    inlineStylesheet,\r\n                    maskInputOptions,\r\n                    maskAttributeFn,\r\n                    maskTextFn,\r\n                    maskInputFn,\r\n                    slimDOMOptions,\r\n                    dataURLOptions,\r\n                    inlineImages,\r\n                    recordCanvas,\r\n                    preserveWhiteSpace,\r\n                    onSerialize,\r\n                    onIframeLoad,\r\n                    iframeLoadTimeout,\r\n                    onStylesheetLoad,\r\n                    stylesheetLoadTimeout,\r\n                    keepIframeSrcFn,\r\n                });\r\n                if (serializedLinkNode) {\r\n                    onStylesheetLoad(n, serializedLinkNode);\r\n                }\r\n            }\r\n        }, stylesheetLoadTimeout);\r\n    }\r\n    return serializedNode;\r\n}\r\nfunction snapshot(n, options) {\r\n    const { mirror = new Mirror(), blockClass = 'rr-block', blockSelector = null, unblockSelector = null, maskAllText = false, maskTextClass = 'rr-mask', unmaskTextClass = null, maskTextSelector = null, unmaskTextSelector = null, inlineStylesheet = true, inlineImages = false, recordCanvas = false, maskAllInputs = false, maskAttributeFn, maskTextFn, maskInputFn, slimDOM = false, dataURLOptions, preserveWhiteSpace, onSerialize, onIframeLoad, iframeLoadTimeout, onStylesheetLoad, stylesheetLoadTimeout, keepIframeSrcFn = () => false, } = options || {};\r\n    const maskInputOptions = maskAllInputs === true\r\n        ? {\r\n            color: true,\r\n            date: true,\r\n            'datetime-local': true,\r\n            email: true,\r\n            month: true,\r\n            number: true,\r\n            range: true,\r\n            search: true,\r\n            tel: true,\r\n            text: true,\r\n            time: true,\r\n            url: true,\r\n            week: true,\r\n            textarea: true,\r\n            select: true,\r\n        }\r\n        : maskAllInputs === false\r\n            ? {}\r\n            : maskAllInputs;\r\n    const slimDOMOptions = slimDOM === true || slimDOM === 'all'\r\n        ?\r\n            {\r\n                script: true,\r\n                comment: true,\r\n                headFavicon: true,\r\n                headWhitespace: true,\r\n                headMetaDescKeywords: slimDOM === 'all',\r\n                headMetaSocial: true,\r\n                headMetaRobots: true,\r\n                headMetaHttpEquiv: true,\r\n                headMetaAuthorship: true,\r\n                headMetaVerification: true,\r\n            }\r\n        : slimDOM === false\r\n            ? {}\r\n            : slimDOM;\r\n    return serializeNodeWithId(n, {\r\n        doc: n,\r\n        mirror,\r\n        blockClass,\r\n        blockSelector,\r\n        unblockSelector,\r\n        maskAllText,\r\n        maskTextClass,\r\n        unmaskTextClass,\r\n        maskTextSelector,\r\n        unmaskTextSelector,\r\n        skipChild: false,\r\n        inlineStylesheet,\r\n        maskInputOptions,\r\n        maskAttributeFn,\r\n        maskTextFn,\r\n        maskInputFn,\r\n        slimDOMOptions,\r\n        dataURLOptions,\r\n        inlineImages,\r\n        recordCanvas,\r\n        preserveWhiteSpace,\r\n        onSerialize,\r\n        onIframeLoad,\r\n        iframeLoadTimeout,\r\n        onStylesheetLoad,\r\n        stylesheetLoadTimeout,\r\n        keepIframeSrcFn,\r\n        newlyAddedElement: false,\r\n    });\r\n}\r\n\nconst commentre = /\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\//g;\r\nfunction parse(css, options = {}) {\r\n    let lineno = 1;\r\n    let column = 1;\r\n    function updatePosition(str) {\r\n        const lines = str.match(/\\n/g);\r\n        if (lines) {\r\n            lineno += lines.length;\r\n        }\r\n        const i = str.lastIndexOf('\\n');\r\n        column = i === -1 ? column + str.length : str.length - i;\r\n    }\r\n    function position() {\r\n        const start = { line: lineno, column };\r\n        return (node) => {\r\n            node.position = new Position(start);\r\n            whitespace();\r\n            return node;\r\n        };\r\n    }\r\n    class Position {\r\n        constructor(start) {\r\n            this.start = start;\r\n            this.end = { line: lineno, column };\r\n            this.source = options.source;\r\n        }\r\n    }\r\n    Position.prototype.content = css;\r\n    const errorsList = [];\r\n    function error(msg) {\r\n        const err = new Error(`${options.source || ''}:${lineno}:${column}: ${msg}`);\r\n        err.reason = msg;\r\n        err.filename = options.source;\r\n        err.line = lineno;\r\n        err.column = column;\r\n        err.source = css;\r\n        if (options.silent) {\r\n            errorsList.push(err);\r\n        }\r\n        else {\r\n            throw err;\r\n        }\r\n    }\r\n    function stylesheet() {\r\n        const rulesList = rules();\r\n        return {\r\n            type: 'stylesheet',\r\n            stylesheet: {\r\n                source: options.source,\r\n                rules: rulesList,\r\n                parsingErrors: errorsList,\r\n            },\r\n        };\r\n    }\r\n    function open() {\r\n        return match(/^{\\s*/);\r\n    }\r\n    function close() {\r\n        return match(/^}/);\r\n    }\r\n    function rules() {\r\n        let node;\r\n        const rules = [];\r\n        whitespace();\r\n        comments(rules);\r\n        while (css.length && css.charAt(0) !== '}' && (node = atrule() || rule())) {\r\n            if (node) {\r\n                rules.push(node);\r\n                comments(rules);\r\n            }\r\n        }\r\n        return rules;\r\n    }\r\n    function match(re) {\r\n        const m = re.exec(css);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        const str = m[0];\r\n        updatePosition(str);\r\n        css = css.slice(str.length);\r\n        return m;\r\n    }\r\n    function whitespace() {\r\n        match(/^\\s*/);\r\n    }\r\n    function comments(rules = []) {\r\n        let c;\r\n        while ((c = comment())) {\r\n            if (c) {\r\n                rules.push(c);\r\n            }\r\n            c = comment();\r\n        }\r\n        return rules;\r\n    }\r\n    function comment() {\r\n        const pos = position();\r\n        if ('/' !== css.charAt(0) || '*' !== css.charAt(1)) {\r\n            return;\r\n        }\r\n        let i = 2;\r\n        while ('' !== css.charAt(i) &&\r\n            ('*' !== css.charAt(i) || '/' !== css.charAt(i + 1))) {\r\n            ++i;\r\n        }\r\n        i += 2;\r\n        if ('' === css.charAt(i - 1)) {\r\n            return error('End of comment missing');\r\n        }\r\n        const str = css.slice(2, i - 2);\r\n        column += 2;\r\n        updatePosition(str);\r\n        css = css.slice(i);\r\n        column += 2;\r\n        return pos({\r\n            type: 'comment',\r\n            comment: str,\r\n        });\r\n    }\r\n    function selector() {\r\n        whitespace();\r\n        while (css[0] == '}') {\r\n            error('extra closing bracket');\r\n            css = css.slice(1);\r\n            whitespace();\r\n        }\r\n        const m = match(/^((\"(?:\\\\\"|[^\"])*\"|'(?:\\\\'|[^'])*'|[^{])+)/);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        const cleanedInput = m[0]\r\n            .trim()\r\n            .replace(/\\/\\*([^*]|[\\r\\n]|(\\*+([^*/]|[\\r\\n])))*\\*\\/+/g, '')\r\n            .replace(/\"(?:\\\\\"|[^\"])*\"|'(?:\\\\'|[^'])*'/g, (m) => {\r\n            return m.replace(/,/g, '\\u200C');\r\n        });\r\n        return customSplit(cleanedInput).map((s) => s.replace(/\\u200C/g, ',').trim());\r\n    }\r\n    function customSplit(input) {\r\n        const result = [];\r\n        let currentSegment = '';\r\n        let depthParentheses = 0;\r\n        let depthBrackets = 0;\r\n        let currentStringChar = null;\r\n        for (const char of input) {\r\n            const hasStringEscape = currentSegment.endsWith('\\\\');\r\n            if (currentStringChar) {\r\n                if (currentStringChar === char && !hasStringEscape) {\r\n                    currentStringChar = null;\r\n                }\r\n            }\r\n            else if (char === '(') {\r\n                depthParentheses++;\r\n            }\r\n            else if (char === ')') {\r\n                depthParentheses--;\r\n            }\r\n            else if (char === '[') {\r\n                depthBrackets++;\r\n            }\r\n            else if (char === ']') {\r\n                depthBrackets--;\r\n            }\r\n            else if ('\\'\"'.includes(char)) {\r\n                currentStringChar = char;\r\n            }\r\n            if (char === ',' && depthParentheses === 0 && depthBrackets === 0) {\r\n                result.push(currentSegment);\r\n                currentSegment = '';\r\n            }\r\n            else {\r\n                currentSegment += char;\r\n            }\r\n        }\r\n        if (currentSegment) {\r\n            result.push(currentSegment);\r\n        }\r\n        return result;\r\n    }\r\n    function declaration() {\r\n        const pos = position();\r\n        const propMatch = match(/^(\\*?[-#\\/\\*\\\\\\w]+(\\[[0-9a-z_-]+\\])?)\\s*/);\r\n        if (!propMatch) {\r\n            return;\r\n        }\r\n        const prop = trim(propMatch[0]);\r\n        if (!match(/^:\\s*/)) {\r\n            return error(`property missing ':'`);\r\n        }\r\n        const val = match(/^((?:'(?:\\\\'|.)*?'|\"(?:\\\\\"|.)*?\"|\\([^\\)]*?\\)|[^};])+)/);\r\n        const ret = pos({\r\n            type: 'declaration',\r\n            property: prop.replace(commentre, ''),\r\n            value: val ? trim(val[0]).replace(commentre, '') : '',\r\n        });\r\n        match(/^[;\\s]*/);\r\n        return ret;\r\n    }\r\n    function declarations() {\r\n        const decls = [];\r\n        if (!open()) {\r\n            return error(`missing '{'`);\r\n        }\r\n        comments(decls);\r\n        let decl;\r\n        while ((decl = declaration())) {\r\n            if (decl !== false) {\r\n                decls.push(decl);\r\n                comments(decls);\r\n            }\r\n            decl = declaration();\r\n        }\r\n        if (!close()) {\r\n            return error(`missing '}'`);\r\n        }\r\n        return decls;\r\n    }\r\n    function keyframe() {\r\n        let m;\r\n        const vals = [];\r\n        const pos = position();\r\n        while ((m = match(/^((\\d+\\.\\d+|\\.\\d+|\\d+)%?|[a-z]+)\\s*/))) {\r\n            vals.push(m[1]);\r\n            match(/^,\\s*/);\r\n        }\r\n        if (!vals.length) {\r\n            return;\r\n        }\r\n        return pos({\r\n            type: 'keyframe',\r\n            values: vals,\r\n            declarations: declarations(),\r\n        });\r\n    }\r\n    function atkeyframes() {\r\n        const pos = position();\r\n        let m = match(/^@([-\\w]+)?keyframes\\s*/);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        const vendor = m[1];\r\n        m = match(/^([-\\w]+)\\s*/);\r\n        if (!m) {\r\n            return error('@keyframes missing name');\r\n        }\r\n        const name = m[1];\r\n        if (!open()) {\r\n            return error(`@keyframes missing '{'`);\r\n        }\r\n        let frame;\r\n        let frames = comments();\r\n        while ((frame = keyframe())) {\r\n            frames.push(frame);\r\n            frames = frames.concat(comments());\r\n        }\r\n        if (!close()) {\r\n            return error(`@keyframes missing '}'`);\r\n        }\r\n        return pos({\r\n            type: 'keyframes',\r\n            name,\r\n            vendor,\r\n            keyframes: frames,\r\n        });\r\n    }\r\n    function atsupports() {\r\n        const pos = position();\r\n        const m = match(/^@supports *([^{]+)/);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        const supports = trim(m[1]);\r\n        if (!open()) {\r\n            return error(`@supports missing '{'`);\r\n        }\r\n        const style = comments().concat(rules());\r\n        if (!close()) {\r\n            return error(`@supports missing '}'`);\r\n        }\r\n        return pos({\r\n            type: 'supports',\r\n            supports,\r\n            rules: style,\r\n        });\r\n    }\r\n    function athost() {\r\n        const pos = position();\r\n        const m = match(/^@host\\s*/);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        if (!open()) {\r\n            return error(`@host missing '{'`);\r\n        }\r\n        const style = comments().concat(rules());\r\n        if (!close()) {\r\n            return error(`@host missing '}'`);\r\n        }\r\n        return pos({\r\n            type: 'host',\r\n            rules: style,\r\n        });\r\n    }\r\n    function atmedia() {\r\n        const pos = position();\r\n        const m = match(/^@media *([^{]+)/);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        const media = trim(m[1]);\r\n        if (!open()) {\r\n            return error(`@media missing '{'`);\r\n        }\r\n        const style = comments().concat(rules());\r\n        if (!close()) {\r\n            return error(`@media missing '}'`);\r\n        }\r\n        return pos({\r\n            type: 'media',\r\n            media,\r\n            rules: style,\r\n        });\r\n    }\r\n    function atcustommedia() {\r\n        const pos = position();\r\n        const m = match(/^@custom-media\\s+(--[^\\s]+)\\s*([^{;]+);/);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        return pos({\r\n            type: 'custom-media',\r\n            name: trim(m[1]),\r\n            media: trim(m[2]),\r\n        });\r\n    }\r\n    function atpage() {\r\n        const pos = position();\r\n        const m = match(/^@page */);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        const sel = selector() || [];\r\n        if (!open()) {\r\n            return error(`@page missing '{'`);\r\n        }\r\n        let decls = comments();\r\n        let decl;\r\n        while ((decl = declaration())) {\r\n            decls.push(decl);\r\n            decls = decls.concat(comments());\r\n        }\r\n        if (!close()) {\r\n            return error(`@page missing '}'`);\r\n        }\r\n        return pos({\r\n            type: 'page',\r\n            selectors: sel,\r\n            declarations: decls,\r\n        });\r\n    }\r\n    function atdocument() {\r\n        const pos = position();\r\n        const m = match(/^@([-\\w]+)?document *([^{]+)/);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        const vendor = trim(m[1]);\r\n        const doc = trim(m[2]);\r\n        if (!open()) {\r\n            return error(`@document missing '{'`);\r\n        }\r\n        const style = comments().concat(rules());\r\n        if (!close()) {\r\n            return error(`@document missing '}'`);\r\n        }\r\n        return pos({\r\n            type: 'document',\r\n            document: doc,\r\n            vendor,\r\n            rules: style,\r\n        });\r\n    }\r\n    function atfontface() {\r\n        const pos = position();\r\n        const m = match(/^@font-face\\s*/);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        if (!open()) {\r\n            return error(`@font-face missing '{'`);\r\n        }\r\n        let decls = comments();\r\n        let decl;\r\n        while ((decl = declaration())) {\r\n            decls.push(decl);\r\n            decls = decls.concat(comments());\r\n        }\r\n        if (!close()) {\r\n            return error(`@font-face missing '}'`);\r\n        }\r\n        return pos({\r\n            type: 'font-face',\r\n            declarations: decls,\r\n        });\r\n    }\r\n    const atimport = _compileAtrule('import');\r\n    const atcharset = _compileAtrule('charset');\r\n    const atnamespace = _compileAtrule('namespace');\r\n    function _compileAtrule(name) {\r\n        const re = new RegExp('^@' + name + '\\\\s*([^;]+);');\r\n        return () => {\r\n            const pos = position();\r\n            const m = match(re);\r\n            if (!m) {\r\n                return;\r\n            }\r\n            const ret = { type: name };\r\n            ret[name] = m[1].trim();\r\n            return pos(ret);\r\n        };\r\n    }\r\n    function atrule() {\r\n        if (css[0] !== '@') {\r\n            return;\r\n        }\r\n        return (atkeyframes() ||\r\n            atmedia() ||\r\n            atcustommedia() ||\r\n            atsupports() ||\r\n            atimport() ||\r\n            atcharset() ||\r\n            atnamespace() ||\r\n            atdocument() ||\r\n            atpage() ||\r\n            athost() ||\r\n            atfontface());\r\n    }\r\n    function rule() {\r\n        const pos = position();\r\n        const sel = selector();\r\n        if (!sel) {\r\n            return error('selector missing');\r\n        }\r\n        comments();\r\n        return pos({\r\n            type: 'rule',\r\n            selectors: sel,\r\n            declarations: declarations(),\r\n        });\r\n    }\r\n    return addParent(stylesheet());\r\n}\r\nfunction trim(str) {\r\n    return str ? str.replace(/^\\s+|\\s+$/g, '') : '';\r\n}\r\nfunction addParent(obj, parent) {\r\n    const isNode = obj && typeof obj.type === 'string';\r\n    const childParent = isNode ? obj : parent;\r\n    for (const k of Object.keys(obj)) {\r\n        const value = obj[k];\r\n        if (Array.isArray(value)) {\r\n            value.forEach((v) => {\r\n                addParent(v, childParent);\r\n            });\r\n        }\r\n        else if (value && typeof value === 'object') {\r\n            addParent(value, childParent);\r\n        }\r\n    }\r\n    if (isNode) {\r\n        Object.defineProperty(obj, 'parent', {\r\n            configurable: true,\r\n            writable: true,\r\n            enumerable: false,\r\n            value: parent || null,\r\n        });\r\n    }\r\n    return obj;\r\n}\n\nconst tagMap = {\r\n    script: 'noscript',\r\n    altglyph: 'altGlyph',\r\n    altglyphdef: 'altGlyphDef',\r\n    altglyphitem: 'altGlyphItem',\r\n    animatecolor: 'animateColor',\r\n    animatemotion: 'animateMotion',\r\n    animatetransform: 'animateTransform',\r\n    clippath: 'clipPath',\r\n    feblend: 'feBlend',\r\n    fecolormatrix: 'feColorMatrix',\r\n    fecomponenttransfer: 'feComponentTransfer',\r\n    fecomposite: 'feComposite',\r\n    feconvolvematrix: 'feConvolveMatrix',\r\n    fediffuselighting: 'feDiffuseLighting',\r\n    fedisplacementmap: 'feDisplacementMap',\r\n    fedistantlight: 'feDistantLight',\r\n    fedropshadow: 'feDropShadow',\r\n    feflood: 'feFlood',\r\n    fefunca: 'feFuncA',\r\n    fefuncb: 'feFuncB',\r\n    fefuncg: 'feFuncG',\r\n    fefuncr: 'feFuncR',\r\n    fegaussianblur: 'feGaussianBlur',\r\n    feimage: 'feImage',\r\n    femerge: 'feMerge',\r\n    femergenode: 'feMergeNode',\r\n    femorphology: 'feMorphology',\r\n    feoffset: 'feOffset',\r\n    fepointlight: 'fePointLight',\r\n    fespecularlighting: 'feSpecularLighting',\r\n    fespotlight: 'feSpotLight',\r\n    fetile: 'feTile',\r\n    feturbulence: 'feTurbulence',\r\n    foreignobject: 'foreignObject',\r\n    glyphref: 'glyphRef',\r\n    lineargradient: 'linearGradient',\r\n    radialgradient: 'radialGradient',\r\n};\r\nfunction getTagName(n) {\r\n    let tagName = tagMap[n.tagName] ? tagMap[n.tagName] : n.tagName;\r\n    if (tagName === 'link' && n.attributes._cssText) {\r\n        tagName = 'style';\r\n    }\r\n    return tagName;\r\n}\r\nfunction escapeRegExp(str) {\r\n    return str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\r\n}\r\nconst HOVER_SELECTOR = /([^\\\\]):hover/;\r\nconst HOVER_SELECTOR_GLOBAL = new RegExp(HOVER_SELECTOR.source, 'g');\r\nfunction addHoverClass(cssText, cache) {\r\n    const cachedStyle = cache?.stylesWithHoverClass.get(cssText);\r\n    if (cachedStyle)\r\n        return cachedStyle;\r\n    if (cssText.length >= 1000000) {\r\n        return cssText;\r\n    }\r\n    const ast = parse(cssText, {\r\n        silent: true,\r\n    });\r\n    if (!ast.stylesheet) {\r\n        return cssText;\r\n    }\r\n    const selectors = [];\r\n    ast.stylesheet.rules.forEach((rule) => {\r\n        if ('selectors' in rule) {\r\n            (rule.selectors || []).forEach((selector) => {\r\n                if (HOVER_SELECTOR.test(selector)) {\r\n                    selectors.push(selector);\r\n                }\r\n            });\r\n        }\r\n    });\r\n    if (selectors.length === 0) {\r\n        return cssText;\r\n    }\r\n    const selectorMatcher = new RegExp(selectors\r\n        .filter((selector, index) => selectors.indexOf(selector) === index)\r\n        .sort((a, b) => b.length - a.length)\r\n        .map((selector) => {\r\n        return escapeRegExp(selector);\r\n    })\r\n        .join('|'), 'g');\r\n    const result = cssText.replace(selectorMatcher, (selector) => {\r\n        const newSelector = selector.replace(HOVER_SELECTOR_GLOBAL, '$1.\\\\:hover');\r\n        return `${selector}, ${newSelector}`;\r\n    });\r\n    cache?.stylesWithHoverClass.set(cssText, result);\r\n    return result;\r\n}\r\nfunction createCache() {\r\n    const stylesWithHoverClass = new Map();\r\n    return {\r\n        stylesWithHoverClass,\r\n    };\r\n}\r\nfunction buildNode(n, options) {\r\n    const { doc, hackCss, cache } = options;\r\n    switch (n.type) {\r\n        case NodeType.Document:\r\n            return doc.implementation.createDocument(null, '', null);\r\n        case NodeType.DocumentType:\r\n            return doc.implementation.createDocumentType(n.name || 'html', n.publicId, n.systemId);\r\n        case NodeType.Element: {\r\n            const tagName = getTagName(n);\r\n            let node;\r\n            if (n.isSVG) {\r\n                node = doc.createElementNS('http://www.w3.org/2000/svg', tagName);\r\n            }\r\n            else {\r\n                if (n.isCustom &&\r\n                    doc.defaultView?.customElements &&\r\n                    !doc.defaultView.customElements.get(n.tagName))\r\n                    doc.defaultView.customElements.define(n.tagName, class extends doc.defaultView.HTMLElement {\r\n                    });\r\n                node = doc.createElement(tagName);\r\n            }\r\n            const specialAttributes = {};\r\n            for (const name in n.attributes) {\r\n                if (!Object.prototype.hasOwnProperty.call(n.attributes, name)) {\r\n                    continue;\r\n                }\r\n                let value = n.attributes[name];\r\n                if (tagName === 'option' &&\r\n                    name === 'selected' &&\r\n                    value === false) {\r\n                    continue;\r\n                }\r\n                if (value === null) {\r\n                    continue;\r\n                }\r\n                if (value === true)\r\n                    value = '';\r\n                if (name.startsWith('rr_')) {\r\n                    specialAttributes[name] = value;\r\n                    continue;\r\n                }\r\n                const isTextarea = tagName === 'textarea' && name === 'value';\r\n                const isRemoteOrDynamicCss = tagName === 'style' && name === '_cssText';\r\n                if (isRemoteOrDynamicCss && hackCss && typeof value === 'string') {\r\n                    value = addHoverClass(value, cache);\r\n                }\r\n                if ((isTextarea || isRemoteOrDynamicCss) && typeof value === 'string') {\r\n                    const child = doc.createTextNode(value);\r\n                    for (const c of Array.from(node.childNodes)) {\r\n                        if (c.nodeType === node.TEXT_NODE) {\r\n                            node.removeChild(c);\r\n                        }\r\n                    }\r\n                    node.appendChild(child);\r\n                    continue;\r\n                }\r\n                try {\r\n                    if (n.isSVG && name === 'xlink:href') {\r\n                        node.setAttributeNS('http://www.w3.org/1999/xlink', name, value.toString());\r\n                    }\r\n                    else if (name === 'onload' ||\r\n                        name === 'onclick' ||\r\n                        name.substring(0, 7) === 'onmouse') {\r\n                        node.setAttribute('_' + name, value.toString());\r\n                    }\r\n                    else if (tagName === 'meta' &&\r\n                        n.attributes['http-equiv'] === 'Content-Security-Policy' &&\r\n                        name === 'content') {\r\n                        node.setAttribute('csp-content', value.toString());\r\n                        continue;\r\n                    }\r\n                    else if (tagName === 'link' &&\r\n                        (n.attributes.rel === 'preload' ||\r\n                            n.attributes.rel === 'modulepreload') &&\r\n                        n.attributes.as === 'script') {\r\n                    }\r\n                    else if (tagName === 'link' &&\r\n                        n.attributes.rel === 'prefetch' &&\r\n                        typeof n.attributes.href === 'string' &&\r\n                        n.attributes.href.endsWith('.js')) {\r\n                    }\r\n                    else if (tagName === 'img' &&\r\n                        n.attributes.srcset &&\r\n                        n.attributes.rr_dataURL) {\r\n                        node.setAttribute('rrweb-original-srcset', n.attributes.srcset);\r\n                    }\r\n                    else {\r\n                        node.setAttribute(name, value.toString());\r\n                    }\r\n                }\r\n                catch (error) {\r\n                }\r\n            }\r\n            for (const name in specialAttributes) {\r\n                const value = specialAttributes[name];\r\n                if (tagName === 'canvas' && name === 'rr_dataURL') {\r\n                    const image = document.createElement('img');\r\n                    image.onload = () => {\r\n                        const ctx = node.getContext('2d');\r\n                        if (ctx) {\r\n                            ctx.drawImage(image, 0, 0, image.width, image.height);\r\n                        }\r\n                    };\r\n                    image.src = value.toString();\r\n                    if (node.RRNodeType)\r\n                        node.rr_dataURL = value.toString();\r\n                }\r\n                else if (tagName === 'img' && name === 'rr_dataURL') {\r\n                    const image = node;\r\n                    if (!image.currentSrc.startsWith('data:')) {\r\n                        image.setAttribute('rrweb-original-src', n.attributes.src);\r\n                        image.src = value.toString();\r\n                    }\r\n                }\r\n                if (name === 'rr_width') {\r\n                    node.style.setProperty('width', value.toString());\r\n                }\r\n                else if (name === 'rr_height') {\r\n                    node.style.setProperty('height', value.toString());\r\n                }\r\n                else if (name === 'rr_mediaCurrentTime' &&\r\n                    typeof value === 'number') {\r\n                    node.currentTime = value;\r\n                }\r\n                else if (name === 'rr_mediaState') {\r\n                    switch (value) {\r\n                        case 'played':\r\n                            node\r\n                                .play()\r\n                                .catch((e) => console.warn('media playback error', e));\r\n                            break;\r\n                        case 'paused':\r\n                            node.pause();\r\n                            break;\r\n                    }\r\n                }\r\n            }\r\n            if (n.isShadowHost) {\r\n                if (!node.shadowRoot) {\r\n                    node.attachShadow({ mode: 'open' });\r\n                }\r\n                else {\r\n                    while (node.shadowRoot.firstChild) {\r\n                        node.shadowRoot.removeChild(node.shadowRoot.firstChild);\r\n                    }\r\n                }\r\n            }\r\n            return node;\r\n        }\r\n        case NodeType.Text:\r\n            return doc.createTextNode(n.isStyle && hackCss\r\n                ? addHoverClass(n.textContent, cache)\r\n                : n.textContent);\r\n        case NodeType.CDATA:\r\n            return doc.createCDATASection(n.textContent);\r\n        case NodeType.Comment:\r\n            return doc.createComment(n.textContent);\r\n        default:\r\n            return null;\r\n    }\r\n}\r\nfunction buildNodeWithSN(n, options) {\r\n    const { doc, mirror, skipChild = false, hackCss = true, afterAppend, cache, } = options;\r\n    if (mirror.has(n.id)) {\r\n        const nodeInMirror = mirror.getNode(n.id);\r\n        const meta = mirror.getMeta(nodeInMirror);\r\n        if (isNodeMetaEqual(meta, n))\r\n            return mirror.getNode(n.id);\r\n    }\r\n    let node = buildNode(n, { doc, hackCss, cache });\r\n    if (!node) {\r\n        return null;\r\n    }\r\n    if (n.rootId && mirror.getNode(n.rootId) !== doc) {\r\n        mirror.replace(n.rootId, doc);\r\n    }\r\n    if (n.type === NodeType.Document) {\r\n        doc.close();\r\n        doc.open();\r\n        if (n.compatMode === 'BackCompat' &&\r\n            n.childNodes &&\r\n            n.childNodes[0].type !== NodeType.DocumentType) {\r\n            if (n.childNodes[0].type === NodeType.Element &&\r\n                'xmlns' in n.childNodes[0].attributes &&\r\n                n.childNodes[0].attributes.xmlns === 'http://www.w3.org/1999/xhtml') {\r\n                doc.write('<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"\">');\r\n            }\r\n            else {\r\n                doc.write('<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\" \"\">');\r\n            }\r\n        }\r\n        node = doc;\r\n    }\r\n    mirror.add(node, n);\r\n    if ((n.type === NodeType.Document || n.type === NodeType.Element) &&\r\n        !skipChild) {\r\n        for (const childN of n.childNodes) {\r\n            const childNode = buildNodeWithSN(childN, {\r\n                doc,\r\n                mirror,\r\n                skipChild: false,\r\n                hackCss,\r\n                afterAppend,\r\n                cache,\r\n            });\r\n            if (!childNode) {\r\n                console.warn('Failed to rebuild', childN);\r\n                continue;\r\n            }\r\n            if (childN.isShadow && isElement(node) && node.shadowRoot) {\r\n                node.shadowRoot.appendChild(childNode);\r\n            }\r\n            else if (n.type === NodeType.Document &&\r\n                childN.type == NodeType.Element) {\r\n                const htmlElement = childNode;\r\n                let body = null;\r\n                htmlElement.childNodes.forEach((child) => {\r\n                    if (child.nodeName === 'BODY')\r\n                        body = child;\r\n                });\r\n                if (body) {\r\n                    htmlElement.removeChild(body);\r\n                    node.appendChild(childNode);\r\n                    htmlElement.appendChild(body);\r\n                }\r\n                else {\r\n                    node.appendChild(childNode);\r\n                }\r\n            }\r\n            else {\r\n                node.appendChild(childNode);\r\n            }\r\n            if (afterAppend) {\r\n                afterAppend(childNode, childN.id);\r\n            }\r\n        }\r\n    }\r\n    return node;\r\n}\r\nfunction visit(mirror, onVisit) {\r\n    function walk(node) {\r\n        onVisit(node);\r\n    }\r\n    for (const id of mirror.getIds()) {\r\n        if (mirror.has(id)) {\r\n            walk(mirror.getNode(id));\r\n        }\r\n    }\r\n}\r\nfunction handleScroll(node, mirror) {\r\n    const n = mirror.getMeta(node);\r\n    if (n?.type !== NodeType.Element) {\r\n        return;\r\n    }\r\n    const el = node;\r\n    for (const name in n.attributes) {\r\n        if (!(Object.prototype.hasOwnProperty.call(n.attributes, name) &&\r\n            name.startsWith('rr_'))) {\r\n            continue;\r\n        }\r\n        const value = n.attributes[name];\r\n        if (name === 'rr_scrollLeft') {\r\n            el.scrollLeft = value;\r\n        }\r\n        if (name === 'rr_scrollTop') {\r\n            el.scrollTop = value;\r\n        }\r\n    }\r\n}\r\nfunction rebuild(n, options) {\r\n    const { doc, onVisit, hackCss = true, afterAppend, cache, mirror = new Mirror(), } = options;\r\n    const node = buildNodeWithSN(n, {\r\n        doc,\r\n        mirror,\r\n        skipChild: false,\r\n        hackCss,\r\n        afterAppend,\r\n        cache,\r\n    });\r\n    visit(mirror, (visitedNode) => {\r\n        if (onVisit) {\r\n            onVisit(visitedNode);\r\n        }\r\n        handleScroll(visitedNode, mirror);\r\n    });\r\n    return node;\r\n}\n\nexport { IGNORED_NODE, Mirror, NodeType, addHoverClass, buildNodeWithSN, createCache, createMatchPredicate, createMirror, distanceToMatch, escapeImportStatement, fixSafariColons, genId, getInputType, getInputValue, ignoreAttribute, is2DCanvasBlank, isCSSImportRule, isCSSStyleRule, isElement, isNativeShadowDom, isNodeMetaEqual, isShadowRoot, maskInputValue, needMaskingText, rebuild, serializeNodeWithId, shouldMaskInput, snapshot, stringifyRule, stringifyStylesheet, toLowerCase, toUpperCase, transformAttribute };\n","import { distanceToMatch, IGNORED_NODE, isShadowRoot, createMatchPredicate } from '../../rrweb-snapshot/es/rrweb-snapshot.js';\n\nfunction on(type, fn, target = document) {\r\n    const options = { capture: true, passive: true };\r\n    target.addEventListener(type, fn, options);\r\n    return () => target.removeEventListener(type, fn, options);\r\n}\r\nconst DEPARTED_MIRROR_ACCESS_WARNING = 'Please stop import mirror directly. Instead of that,' +\r\n    '\\r\\n' +\r\n    'now you can use replayer.getMirror() to access the mirror instance of a replayer,' +\r\n    '\\r\\n' +\r\n    'or you can use record.mirror to access the mirror instance during recording.';\r\nlet _mirror = {\r\n    map: {},\r\n    getId() {\r\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\r\n        return -1;\r\n    },\r\n    getNode() {\r\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\r\n        return null;\r\n    },\r\n    removeNodeFromMap() {\r\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\r\n    },\r\n    has() {\r\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\r\n        return false;\r\n    },\r\n    reset() {\r\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\r\n    },\r\n};\r\nif (typeof window !== 'undefined' && window.Proxy && window.Reflect) {\r\n    _mirror = new Proxy(_mirror, {\r\n        get(target, prop, receiver) {\r\n            if (prop === 'map') {\r\n                console.error(DEPARTED_MIRROR_ACCESS_WARNING);\r\n            }\r\n            return Reflect.get(target, prop, receiver);\r\n        },\r\n    });\r\n}\r\nfunction throttle(func, wait, options = {}) {\r\n    let timeout = null;\r\n    let previous = 0;\r\n    return function (...args) {\r\n        const now = Date.now();\r\n        if (!previous && options.leading === false) {\r\n            previous = now;\r\n        }\r\n        const remaining = wait - (now - previous);\r\n        const context = this;\r\n        if (remaining <= 0 || remaining > wait) {\r\n            if (timeout) {\r\n                clearTimeout(timeout);\r\n                timeout = null;\r\n            }\r\n            previous = now;\r\n            func.apply(context, args);\r\n        }\r\n        else if (!timeout && options.trailing !== false) {\r\n            timeout = setTimeout(() => {\r\n                previous = options.leading === false ? 0 : Date.now();\r\n                timeout = null;\r\n                func.apply(context, args);\r\n            }, remaining);\r\n        }\r\n    };\r\n}\r\nfunction hookSetter(target, key, d, isRevoked, win = window) {\r\n    const original = win.Object.getOwnPropertyDescriptor(target, key);\r\n    win.Object.defineProperty(target, key, isRevoked\r\n        ? d\r\n        : {\r\n            set(value) {\r\n                setTimeout(() => {\r\n                    d.set.call(this, value);\r\n                }, 0);\r\n                if (original && original.set) {\r\n                    original.set.call(this, value);\r\n                }\r\n            },\r\n        });\r\n    return () => hookSetter(target, key, original || {}, true);\r\n}\r\nfunction patch(source, name, replacement) {\r\n    try {\r\n        if (!(name in source)) {\r\n            return () => {\r\n            };\r\n        }\r\n        const original = source[name];\r\n        const wrapped = replacement(original);\r\n        if (typeof wrapped === 'function') {\r\n            wrapped.prototype = wrapped.prototype || {};\r\n            Object.defineProperties(wrapped, {\r\n                __rrweb_original__: {\r\n                    enumerable: false,\r\n                    value: original,\r\n                },\r\n            });\r\n        }\r\n        source[name] = wrapped;\r\n        return () => {\r\n            source[name] = original;\r\n        };\r\n    }\r\n    catch {\r\n        return () => {\r\n        };\r\n    }\r\n}\r\nlet nowTimestamp = Date.now;\r\nif (!(/[1-9][0-9]{12}/.test(Date.now().toString()))) {\r\n    nowTimestamp = () => new Date().getTime();\r\n}\r\nfunction getWindowScroll(win) {\r\n    const doc = win.document;\r\n    return {\r\n        left: doc.scrollingElement\r\n            ? doc.scrollingElement.scrollLeft\r\n            : win.pageXOffset !== undefined\r\n                ? win.pageXOffset\r\n                : doc?.documentElement.scrollLeft ||\r\n                    doc?.body?.parentElement?.scrollLeft ||\r\n                    doc?.body?.scrollLeft ||\r\n                    0,\r\n        top: doc.scrollingElement\r\n            ? doc.scrollingElement.scrollTop\r\n            : win.pageYOffset !== undefined\r\n                ? win.pageYOffset\r\n                : doc?.documentElement.scrollTop ||\r\n                    doc?.body?.parentElement?.scrollTop ||\r\n                    doc?.body?.scrollTop ||\r\n                    0,\r\n    };\r\n}\r\nfunction getWindowHeight() {\r\n    return (window.innerHeight ||\r\n        (document.documentElement && document.documentElement.clientHeight) ||\r\n        (document.body && document.body.clientHeight));\r\n}\r\nfunction getWindowWidth() {\r\n    return (window.innerWidth ||\r\n        (document.documentElement && document.documentElement.clientWidth) ||\r\n        (document.body && document.body.clientWidth));\r\n}\r\nfunction closestElementOfNode(node) {\r\n    if (!node) {\r\n        return null;\r\n    }\r\n    const el = node.nodeType === node.ELEMENT_NODE\r\n        ? node\r\n        : node.parentElement;\r\n    return el;\r\n}\r\nfunction isBlocked(node, blockClass, blockSelector, unblockSelector, checkAncestors) {\r\n    if (!node) {\r\n        return false;\r\n    }\r\n    const el = closestElementOfNode(node);\r\n    if (!el) {\r\n        return false;\r\n    }\r\n    const blockedPredicate = createMatchPredicate(blockClass, blockSelector);\r\n    if (!checkAncestors) {\r\n        const isUnblocked = unblockSelector && el.matches(unblockSelector);\r\n        return blockedPredicate(el) && !isUnblocked;\r\n    }\r\n    const blockDistance = distanceToMatch(el, blockedPredicate);\r\n    let unblockDistance = -1;\r\n    if (blockDistance < 0) {\r\n        return false;\r\n    }\r\n    if (unblockSelector) {\r\n        unblockDistance = distanceToMatch(el, createMatchPredicate(null, unblockSelector));\r\n    }\r\n    if (blockDistance > -1 && unblockDistance < 0) {\r\n        return true;\r\n    }\r\n    return blockDistance < unblockDistance;\r\n}\r\nfunction isSerialized(n, mirror) {\r\n    return mirror.getId(n) !== -1;\r\n}\r\nfunction isIgnored(n, mirror) {\r\n    return mirror.getId(n) === IGNORED_NODE;\r\n}\r\nfunction isAncestorRemoved(target, mirror) {\r\n    if (isShadowRoot(target)) {\r\n        return false;\r\n    }\r\n    const id = mirror.getId(target);\r\n    if (!mirror.has(id)) {\r\n        return true;\r\n    }\r\n    if (target.parentNode &&\r\n        target.parentNode.nodeType === target.DOCUMENT_NODE) {\r\n        return false;\r\n    }\r\n    if (!target.parentNode) {\r\n        return true;\r\n    }\r\n    return isAncestorRemoved(target.parentNode, mirror);\r\n}\r\nfunction legacy_isTouchEvent(event) {\r\n    return Boolean(event.changedTouches);\r\n}\r\nfunction polyfill(win = window) {\r\n    if ('NodeList' in win && !win.NodeList.prototype.forEach) {\r\n        win.NodeList.prototype.forEach = Array.prototype\r\n            .forEach;\r\n    }\r\n    if ('DOMTokenList' in win && !win.DOMTokenList.prototype.forEach) {\r\n        win.DOMTokenList.prototype.forEach = Array.prototype\r\n            .forEach;\r\n    }\r\n    if (!Node.prototype.contains) {\r\n        Node.prototype.contains = (...args) => {\r\n            let node = args[0];\r\n            if (!(0 in args)) {\r\n                throw new TypeError('1 argument is required');\r\n            }\r\n            do {\r\n                if (this === node) {\r\n                    return true;\r\n                }\r\n            } while ((node = node && node.parentNode));\r\n            return false;\r\n        };\r\n    }\r\n}\r\nfunction queueToResolveTrees(queue) {\r\n    const queueNodeMap = {};\r\n    const putIntoMap = (m, parent) => {\r\n        const nodeInTree = {\r\n            value: m,\r\n            parent,\r\n            children: [],\r\n        };\r\n        queueNodeMap[m.node.id] = nodeInTree;\r\n        return nodeInTree;\r\n    };\r\n    const queueNodeTrees = [];\r\n    for (const mutation of queue) {\r\n        const { nextId, parentId } = mutation;\r\n        if (nextId && nextId in queueNodeMap) {\r\n            const nextInTree = queueNodeMap[nextId];\r\n            if (nextInTree.parent) {\r\n                const idx = nextInTree.parent.children.indexOf(nextInTree);\r\n                nextInTree.parent.children.splice(idx, 0, putIntoMap(mutation, nextInTree.parent));\r\n            }\r\n            else {\r\n                const idx = queueNodeTrees.indexOf(nextInTree);\r\n                queueNodeTrees.splice(idx, 0, putIntoMap(mutation, null));\r\n            }\r\n            continue;\r\n        }\r\n        if (parentId in queueNodeMap) {\r\n            const parentInTree = queueNodeMap[parentId];\r\n            parentInTree.children.push(putIntoMap(mutation, parentInTree));\r\n            continue;\r\n        }\r\n        queueNodeTrees.push(putIntoMap(mutation, null));\r\n    }\r\n    return queueNodeTrees;\r\n}\r\nfunction iterateResolveTree(tree, cb) {\r\n    cb(tree.value);\r\n    for (let i = tree.children.length - 1; i >= 0; i--) {\r\n        iterateResolveTree(tree.children[i], cb);\r\n    }\r\n}\r\nfunction isSerializedIframe(n, mirror) {\r\n    return Boolean(n.nodeName === 'IFRAME' && mirror.getMeta(n));\r\n}\r\nfunction isSerializedStylesheet(n, mirror) {\r\n    return Boolean(n.nodeName === 'LINK' &&\r\n        n.nodeType === n.ELEMENT_NODE &&\r\n        n.getAttribute &&\r\n        n.getAttribute('rel') === 'stylesheet' &&\r\n        mirror.getMeta(n));\r\n}\r\nfunction getBaseDimension(node, rootIframe) {\r\n    const frameElement = node.ownerDocument?.defaultView?.frameElement;\r\n    if (!frameElement || frameElement === rootIframe) {\r\n        return {\r\n            x: 0,\r\n            y: 0,\r\n            relativeScale: 1,\r\n            absoluteScale: 1,\r\n        };\r\n    }\r\n    const frameDimension = frameElement.getBoundingClientRect();\r\n    const frameBaseDimension = getBaseDimension(frameElement, rootIframe);\r\n    const relativeScale = frameDimension.height / frameElement.clientHeight;\r\n    return {\r\n        x: frameDimension.x * frameBaseDimension.relativeScale +\r\n            frameBaseDimension.x,\r\n        y: frameDimension.y * frameBaseDimension.relativeScale +\r\n            frameBaseDimension.y,\r\n        relativeScale,\r\n        absoluteScale: frameBaseDimension.absoluteScale * relativeScale,\r\n    };\r\n}\r\nfunction hasShadowRoot(n) {\r\n    return Boolean(n?.shadowRoot);\r\n}\r\nfunction getNestedRule(rules, position) {\r\n    const rule = rules[position[0]];\r\n    if (position.length === 1) {\r\n        return rule;\r\n    }\r\n    else {\r\n        return getNestedRule(rule.cssRules[position[1]].cssRules, position.slice(2));\r\n    }\r\n}\r\nfunction getPositionsAndIndex(nestedIndex) {\r\n    const positions = [...nestedIndex];\r\n    const index = positions.pop();\r\n    return { positions, index };\r\n}\r\nfunction uniqueTextMutations(mutations) {\r\n    const idSet = new Set();\r\n    const uniqueMutations = [];\r\n    for (let i = mutations.length; i--;) {\r\n        const mutation = mutations[i];\r\n        if (!idSet.has(mutation.id)) {\r\n            uniqueMutations.push(mutation);\r\n            idSet.add(mutation.id);\r\n        }\r\n    }\r\n    return uniqueMutations;\r\n}\r\nclass StyleSheetMirror {\r\n    constructor() {\r\n        this.id = 1;\r\n        this.styleIDMap = new WeakMap();\r\n        this.idStyleMap = new Map();\r\n    }\r\n    getId(stylesheet) {\r\n        return this.styleIDMap.get(stylesheet) ?? -1;\r\n    }\r\n    has(stylesheet) {\r\n        return this.styleIDMap.has(stylesheet);\r\n    }\r\n    add(stylesheet, id) {\r\n        if (this.has(stylesheet))\r\n            return this.getId(stylesheet);\r\n        let newId;\r\n        if (id === undefined) {\r\n            newId = this.id++;\r\n        }\r\n        else\r\n            newId = id;\r\n        this.styleIDMap.set(stylesheet, newId);\r\n        this.idStyleMap.set(newId, stylesheet);\r\n        return newId;\r\n    }\r\n    getStyle(id) {\r\n        return this.idStyleMap.get(id) || null;\r\n    }\r\n    reset() {\r\n        this.styleIDMap = new WeakMap();\r\n        this.idStyleMap = new Map();\r\n        this.id = 1;\r\n    }\r\n    generateId() {\r\n        return this.id++;\r\n    }\r\n}\r\nfunction getShadowHost(n) {\r\n    let shadowHost = null;\r\n    if (n.getRootNode?.()?.nodeType === Node.DOCUMENT_FRAGMENT_NODE &&\r\n        n.getRootNode().host)\r\n        shadowHost = n.getRootNode().host;\r\n    return shadowHost;\r\n}\r\nfunction getRootShadowHost(n) {\r\n    let rootShadowHost = n;\r\n    let shadowHost;\r\n    while ((shadowHost = getShadowHost(rootShadowHost)))\r\n        rootShadowHost = shadowHost;\r\n    return rootShadowHost;\r\n}\r\nfunction shadowHostInDom(n) {\r\n    const doc = n.ownerDocument;\r\n    if (!doc)\r\n        return false;\r\n    const shadowHost = getRootShadowHost(n);\r\n    return doc.contains(shadowHost);\r\n}\r\nfunction inDom(n) {\r\n    const doc = n.ownerDocument;\r\n    if (!doc)\r\n        return false;\r\n    return doc.contains(n) || shadowHostInDom(n);\r\n}\r\nconst cachedImplementations = {};\r\nfunction getImplementation(name) {\r\n    const cached = cachedImplementations[name];\r\n    if (cached) {\r\n        return cached;\r\n    }\r\n    const document = window.document;\r\n    let impl = window[name];\r\n    if (document && typeof document.createElement === 'function') {\r\n        try {\r\n            const sandbox = document.createElement('iframe');\r\n            sandbox.hidden = true;\r\n            document.head.appendChild(sandbox);\r\n            const contentWindow = sandbox.contentWindow;\r\n            if (contentWindow && contentWindow[name]) {\r\n                impl =\r\n                    contentWindow[name];\r\n            }\r\n            document.head.removeChild(sandbox);\r\n        }\r\n        catch (e) {\r\n        }\r\n    }\r\n    return (cachedImplementations[name] = impl.bind(window));\r\n}\r\nfunction onRequestAnimationFrame(...rest) {\r\n    return getImplementation('requestAnimationFrame')(...rest);\r\n}\r\nfunction setTimeout(...rest) {\r\n    return getImplementation('setTimeout')(...rest);\r\n}\r\nfunction clearTimeout(...rest) {\r\n    return getImplementation('clearTimeout')(...rest);\r\n}\n\nexport { StyleSheetMirror, _mirror, clearTimeout, closestElementOfNode, getBaseDimension, getNestedRule, getPositionsAndIndex, getRootShadowHost, getShadowHost, getWindowHeight, getWindowScroll, getWindowWidth, hasShadowRoot, hookSetter, inDom, isAncestorRemoved, isBlocked, isIgnored, isSerialized, isSerializedIframe, isSerializedStylesheet, iterateResolveTree, legacy_isTouchEvent, nowTimestamp, on, onRequestAnimationFrame, patch, polyfill, queueToResolveTrees, setTimeout, shadowHostInDom, throttle, uniqueTextMutations };\n","// https://github.com/alangpierce/sucrase/tree/265887868966917f3b924ce38dfad01fbab1329f\n//\n// The MIT License (MIT)\n//\n// Copyright (c) 2012-2018 various contributors (see AUTHORS)\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\n/**\n * Polyfill for the nullish coalescing operator (`??`).\n *\n * Note that the RHS is wrapped in a function so that if it's a computed value, that evaluation won't happen unless the\n * LHS evaluates to a nullish value, to mimic the operator's short-circuiting behavior.\n *\n * Adapted from Sucrase (https://github.com/alangpierce/sucrase)\n *\n * @param lhs The value of the expression to the left of the `??`\n * @param rhsFn A function returning the value of the expression to the right of the `??`\n * @returns The LHS value, unless it's `null` or `undefined`, in which case, the RHS value\n */\nexport function _nullishCoalesce(lhs: unknown, rhsFn: () => unknown): unknown {\n  // by checking for loose equality to `null`, we catch both `null` and `undefined`\n  return lhs != null ? lhs : rhsFn();\n}\n\n// Sucrase version:\n// function _nullishCoalesce(lhs, rhsFn) {\n//   if (lhs != null) {\n//     return lhs;\n//   } else {\n//     return rhsFn();\n//   }\n// }\n","var EventType = /* @__PURE__ */ ((EventType2) => {\n  EventType2[EventType2[\"DomContentLoaded\"] = 0] = \"DomContentLoaded\";\n  EventType2[EventType2[\"Load\"] = 1] = \"Load\";\n  EventType2[EventType2[\"FullSnapshot\"] = 2] = \"FullSnapshot\";\n  EventType2[EventType2[\"IncrementalSnapshot\"] = 3] = \"IncrementalSnapshot\";\n  EventType2[EventType2[\"Meta\"] = 4] = \"Meta\";\n  EventType2[EventType2[\"Custom\"] = 5] = \"Custom\";\n  EventType2[EventType2[\"Plugin\"] = 6] = \"Plugin\";\n  return EventType2;\n})(EventType || {});\nvar IncrementalSource = /* @__PURE__ */ ((IncrementalSource2) => {\n  IncrementalSource2[IncrementalSource2[\"Mutation\"] = 0] = \"Mutation\";\n  IncrementalSource2[IncrementalSource2[\"MouseMove\"] = 1] = \"MouseMove\";\n  IncrementalSource2[IncrementalSource2[\"MouseInteraction\"] = 2] = \"MouseInteraction\";\n  IncrementalSource2[IncrementalSource2[\"Scroll\"] = 3] = \"Scroll\";\n  IncrementalSource2[IncrementalSource2[\"ViewportResize\"] = 4] = \"ViewportResize\";\n  IncrementalSource2[IncrementalSource2[\"Input\"] = 5] = \"Input\";\n  IncrementalSource2[IncrementalSource2[\"TouchMove\"] = 6] = \"TouchMove\";\n  IncrementalSource2[IncrementalSource2[\"MediaInteraction\"] = 7] = \"MediaInteraction\";\n  IncrementalSource2[IncrementalSource2[\"StyleSheetRule\"] = 8] = \"StyleSheetRule\";\n  IncrementalSource2[IncrementalSource2[\"CanvasMutation\"] = 9] = \"CanvasMutation\";\n  IncrementalSource2[IncrementalSource2[\"Font\"] = 10] = \"Font\";\n  IncrementalSource2[IncrementalSource2[\"Log\"] = 11] = \"Log\";\n  IncrementalSource2[IncrementalSource2[\"Drag\"] = 12] = \"Drag\";\n  IncrementalSource2[IncrementalSource2[\"StyleDeclaration\"] = 13] = \"StyleDeclaration\";\n  IncrementalSource2[IncrementalSource2[\"Selection\"] = 14] = \"Selection\";\n  IncrementalSource2[IncrementalSource2[\"AdoptedStyleSheet\"] = 15] = \"AdoptedStyleSheet\";\n  IncrementalSource2[IncrementalSource2[\"CustomElement\"] = 16] = \"CustomElement\";\n  return IncrementalSource2;\n})(IncrementalSource || {});\nvar MouseInteractions = /* @__PURE__ */ ((MouseInteractions2) => {\n  MouseInteractions2[MouseInteractions2[\"MouseUp\"] = 0] = \"MouseUp\";\n  MouseInteractions2[MouseInteractions2[\"MouseDown\"] = 1] = \"MouseDown\";\n  MouseInteractions2[MouseInteractions2[\"Click\"] = 2] = \"Click\";\n  MouseInteractions2[MouseInteractions2[\"ContextMenu\"] = 3] = \"ContextMenu\";\n  MouseInteractions2[MouseInteractions2[\"DblClick\"] = 4] = \"DblClick\";\n  MouseInteractions2[MouseInteractions2[\"Focus\"] = 5] = \"Focus\";\n  MouseInteractions2[MouseInteractions2[\"Blur\"] = 6] = \"Blur\";\n  MouseInteractions2[MouseInteractions2[\"TouchStart\"] = 7] = \"TouchStart\";\n  MouseInteractions2[MouseInteractions2[\"TouchMove_Departed\"] = 8] = \"TouchMove_Departed\";\n  MouseInteractions2[MouseInteractions2[\"TouchEnd\"] = 9] = \"TouchEnd\";\n  MouseInteractions2[MouseInteractions2[\"TouchCancel\"] = 10] = \"TouchCancel\";\n  return MouseInteractions2;\n})(MouseInteractions || {});\nvar PointerTypes = /* @__PURE__ */ ((PointerTypes2) => {\n  PointerTypes2[PointerTypes2[\"Mouse\"] = 0] = \"Mouse\";\n  PointerTypes2[PointerTypes2[\"Pen\"] = 1] = \"Pen\";\n  PointerTypes2[PointerTypes2[\"Touch\"] = 2] = \"Touch\";\n  return PointerTypes2;\n})(PointerTypes || {});\nvar CanvasContext = /* @__PURE__ */ ((CanvasContext2) => {\n  CanvasContext2[CanvasContext2[\"2D\"] = 0] = \"2D\";\n  CanvasContext2[CanvasContext2[\"WebGL\"] = 1] = \"WebGL\";\n  CanvasContext2[CanvasContext2[\"WebGL2\"] = 2] = \"WebGL2\";\n  return CanvasContext2;\n})(CanvasContext || {});\nvar ReplayerEvents = /* @__PURE__ */ ((ReplayerEvents2) => {\n  ReplayerEvents2[\"Start\"] = \"start\";\n  ReplayerEvents2[\"Pause\"] = \"pause\";\n  ReplayerEvents2[\"Resume\"] = \"resume\";\n  ReplayerEvents2[\"Resize\"] = \"resize\";\n  ReplayerEvents2[\"Finish\"] = \"finish\";\n  ReplayerEvents2[\"FullsnapshotRebuilded\"] = \"fullsnapshot-rebuilded\";\n  ReplayerEvents2[\"LoadStylesheetStart\"] = \"load-stylesheet-start\";\n  ReplayerEvents2[\"LoadStylesheetEnd\"] = \"load-stylesheet-end\";\n  ReplayerEvents2[\"SkipStart\"] = \"skip-start\";\n  ReplayerEvents2[\"SkipEnd\"] = \"skip-end\";\n  ReplayerEvents2[\"MouseInteraction\"] = \"mouse-interaction\";\n  ReplayerEvents2[\"EventCast\"] = \"event-cast\";\n  ReplayerEvents2[\"CustomEvent\"] = \"custom-event\";\n  ReplayerEvents2[\"Flush\"] = \"flush\";\n  ReplayerEvents2[\"StateChange\"] = \"state-change\";\n  ReplayerEvents2[\"PlayBack\"] = \"play-back\";\n  ReplayerEvents2[\"Destroy\"] = \"destroy\";\n  return ReplayerEvents2;\n})(ReplayerEvents || {});\n\nexport { CanvasContext, EventType, IncrementalSource, MouseInteractions, PointerTypes, ReplayerEvents };\n","import { isShadowRoot, isNativeShadowDom, getInputType, getInputValue, shouldMaskInput, needMaskingText, maskInputValue, ignoreAttribute, transformAttribute, toLowerCase, IGNORED_NODE, serializeNodeWithId } from '../../../rrweb-snapshot/es/rrweb-snapshot.js';\nimport { isIgnored, isBlocked, isSerialized, isAncestorRemoved, closestElementOfNode, hasShadowRoot, inDom, getShadowHost, isSerializedIframe, isSerializedStylesheet } from '../utils.js';\n\nfunction isNodeInLinkedList(n) {\r\n    return '__ln' in n;\r\n}\r\nclass DoubleLinkedList {\r\n    constructor() {\r\n        this.length = 0;\r\n        this.head = null;\r\n        this.tail = null;\r\n    }\r\n    get(position) {\r\n        if (position >= this.length) {\r\n            throw new Error('Position outside of list range');\r\n        }\r\n        let current = this.head;\r\n        for (let index = 0; index < position; index++) {\r\n            current = current?.next || null;\r\n        }\r\n        return current;\r\n    }\r\n    addNode(n) {\r\n        const node = {\r\n            value: n,\r\n            previous: null,\r\n            next: null,\r\n        };\r\n        n.__ln = node;\r\n        if (n.previousSibling && isNodeInLinkedList(n.previousSibling)) {\r\n            const current = n.previousSibling.__ln.next;\r\n            node.next = current;\r\n            node.previous = n.previousSibling.__ln;\r\n            n.previousSibling.__ln.next = node;\r\n            if (current) {\r\n                current.previous = node;\r\n            }\r\n        }\r\n        else if (n.nextSibling &&\r\n            isNodeInLinkedList(n.nextSibling) &&\r\n            n.nextSibling.__ln.previous) {\r\n            const current = n.nextSibling.__ln.previous;\r\n            node.previous = current;\r\n            node.next = n.nextSibling.__ln;\r\n            n.nextSibling.__ln.previous = node;\r\n            if (current) {\r\n                current.next = node;\r\n            }\r\n        }\r\n        else {\r\n            if (this.head) {\r\n                this.head.previous = node;\r\n            }\r\n            node.next = this.head;\r\n            this.head = node;\r\n        }\r\n        if (node.next === null) {\r\n            this.tail = node;\r\n        }\r\n        this.length++;\r\n    }\r\n    removeNode(n) {\r\n        const current = n.__ln;\r\n        if (!this.head) {\r\n            return;\r\n        }\r\n        if (!current.previous) {\r\n            this.head = current.next;\r\n            if (this.head) {\r\n                this.head.previous = null;\r\n            }\r\n            else {\r\n                this.tail = null;\r\n            }\r\n        }\r\n        else {\r\n            current.previous.next = current.next;\r\n            if (current.next) {\r\n                current.next.previous = current.previous;\r\n            }\r\n            else {\r\n                this.tail = current.previous;\r\n            }\r\n        }\r\n        if (n.__ln) {\r\n            delete n.__ln;\r\n        }\r\n        this.length--;\r\n    }\r\n}\r\nconst moveKey = (id, parentId) => `${id}@${parentId}`;\r\nclass MutationBuffer {\r\n    constructor() {\r\n        this.frozen = false;\r\n        this.locked = false;\r\n        this.texts = [];\r\n        this.attributes = [];\r\n        this.attributeMap = new WeakMap();\r\n        this.removes = [];\r\n        this.mapRemoves = [];\r\n        this.movedMap = {};\r\n        this.addedSet = new Set();\r\n        this.movedSet = new Set();\r\n        this.droppedSet = new Set();\r\n        this.processMutations = (mutations) => {\r\n            mutations.forEach(this.processMutation);\r\n            this.emit();\r\n        };\r\n        this.emit = () => {\r\n            if (this.frozen || this.locked) {\r\n                return;\r\n            }\r\n            const adds = [];\r\n            const addedIds = new Set();\r\n            const addList = new DoubleLinkedList();\r\n            const getNextId = (n) => {\r\n                let ns = n;\r\n                let nextId = IGNORED_NODE;\r\n                while (nextId === IGNORED_NODE) {\r\n                    ns = ns && ns.nextSibling;\r\n                    nextId = ns && this.mirror.getId(ns);\r\n                }\r\n                return nextId;\r\n            };\r\n            const pushAdd = (n) => {\r\n                if (!n.parentNode || !inDom(n)) {\r\n                    return;\r\n                }\r\n                const parentId = isShadowRoot(n.parentNode)\r\n                    ? this.mirror.getId(getShadowHost(n))\r\n                    : this.mirror.getId(n.parentNode);\r\n                const nextId = getNextId(n);\r\n                if (parentId === -1 || nextId === -1) {\r\n                    return addList.addNode(n);\r\n                }\r\n                const sn = serializeNodeWithId(n, {\r\n                    doc: this.doc,\r\n                    mirror: this.mirror,\r\n                    blockClass: this.blockClass,\r\n                    blockSelector: this.blockSelector,\r\n                    maskAllText: this.maskAllText,\r\n                    unblockSelector: this.unblockSelector,\r\n                    maskTextClass: this.maskTextClass,\r\n                    unmaskTextClass: this.unmaskTextClass,\r\n                    maskTextSelector: this.maskTextSelector,\r\n                    unmaskTextSelector: this.unmaskTextSelector,\r\n                    skipChild: true,\r\n                    newlyAddedElement: true,\r\n                    inlineStylesheet: this.inlineStylesheet,\r\n                    maskInputOptions: this.maskInputOptions,\r\n                    maskAttributeFn: this.maskAttributeFn,\r\n                    maskTextFn: this.maskTextFn,\r\n                    maskInputFn: this.maskInputFn,\r\n                    slimDOMOptions: this.slimDOMOptions,\r\n                    dataURLOptions: this.dataURLOptions,\r\n                    recordCanvas: this.recordCanvas,\r\n                    inlineImages: this.inlineImages,\r\n                    onSerialize: (currentN) => {\r\n                        if (isSerializedIframe(currentN, this.mirror)) {\r\n                            this.iframeManager.addIframe(currentN);\r\n                        }\r\n                        if (isSerializedStylesheet(currentN, this.mirror)) {\r\n                            this.stylesheetManager.trackLinkElement(currentN);\r\n                        }\r\n                        if (hasShadowRoot(n)) {\r\n                            this.shadowDomManager.addShadowRoot(n.shadowRoot, this.doc);\r\n                        }\r\n                    },\r\n                    onIframeLoad: (iframe, childSn) => {\r\n                        this.iframeManager.attachIframe(iframe, childSn);\r\n                        this.shadowDomManager.observeAttachShadow(iframe);\r\n                    },\r\n                    onStylesheetLoad: (link, childSn) => {\r\n                        this.stylesheetManager.attachLinkElement(link, childSn);\r\n                    },\r\n                });\r\n                if (sn) {\r\n                    adds.push({\r\n                        parentId,\r\n                        nextId,\r\n                        node: sn,\r\n                    });\r\n                    addedIds.add(sn.id);\r\n                }\r\n            };\r\n            while (this.mapRemoves.length) {\r\n                this.mirror.removeNodeFromMap(this.mapRemoves.shift());\r\n            }\r\n            for (const n of this.movedSet) {\r\n                if (isParentRemoved(this.removes, n, this.mirror) &&\r\n                    !this.movedSet.has(n.parentNode)) {\r\n                    continue;\r\n                }\r\n                pushAdd(n);\r\n            }\r\n            for (const n of this.addedSet) {\r\n                if (!isAncestorInSet(this.droppedSet, n) &&\r\n                    !isParentRemoved(this.removes, n, this.mirror)) {\r\n                    pushAdd(n);\r\n                }\r\n                else if (isAncestorInSet(this.movedSet, n)) {\r\n                    pushAdd(n);\r\n                }\r\n                else {\r\n                    this.droppedSet.add(n);\r\n                }\r\n            }\r\n            let candidate = null;\r\n            while (addList.length) {\r\n                let node = null;\r\n                if (candidate) {\r\n                    const parentId = this.mirror.getId(candidate.value.parentNode);\r\n                    const nextId = getNextId(candidate.value);\r\n                    if (parentId !== -1 && nextId !== -1) {\r\n                        node = candidate;\r\n                    }\r\n                }\r\n                if (!node) {\r\n                    let tailNode = addList.tail;\r\n                    while (tailNode) {\r\n                        const _node = tailNode;\r\n                        tailNode = tailNode.previous;\r\n                        if (_node) {\r\n                            const parentId = this.mirror.getId(_node.value.parentNode);\r\n                            const nextId = getNextId(_node.value);\r\n                            if (nextId === -1)\r\n                                continue;\r\n                            else if (parentId !== -1) {\r\n                                node = _node;\r\n                                break;\r\n                            }\r\n                            else {\r\n                                const unhandledNode = _node.value;\r\n                                if (unhandledNode.parentNode &&\r\n                                    unhandledNode.parentNode.nodeType ===\r\n                                        Node.DOCUMENT_FRAGMENT_NODE) {\r\n                                    const shadowHost = unhandledNode.parentNode\r\n                                        .host;\r\n                                    const parentId = this.mirror.getId(shadowHost);\r\n                                    if (parentId !== -1) {\r\n                                        node = _node;\r\n                                        break;\r\n                                    }\r\n                                }\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n                if (!node) {\r\n                    while (addList.head) {\r\n                        addList.removeNode(addList.head.value);\r\n                    }\r\n                    break;\r\n                }\r\n                candidate = node.previous;\r\n                addList.removeNode(node.value);\r\n                pushAdd(node.value);\r\n            }\r\n            const payload = {\r\n                texts: this.texts\r\n                    .map((text) => ({\r\n                    id: this.mirror.getId(text.node),\r\n                    value: text.value,\r\n                }))\r\n                    .filter((text) => !addedIds.has(text.id))\r\n                    .filter((text) => this.mirror.has(text.id)),\r\n                attributes: this.attributes\r\n                    .map((attribute) => {\r\n                    const { attributes } = attribute;\r\n                    if (typeof attributes.style === 'string') {\r\n                        const diffAsStr = JSON.stringify(attribute.styleDiff);\r\n                        const unchangedAsStr = JSON.stringify(attribute._unchangedStyles);\r\n                        if (diffAsStr.length < attributes.style.length) {\r\n                            if ((diffAsStr + unchangedAsStr).split('var(').length ===\r\n                                attributes.style.split('var(').length) {\r\n                                attributes.style = attribute.styleDiff;\r\n                            }\r\n                        }\r\n                    }\r\n                    return {\r\n                        id: this.mirror.getId(attribute.node),\r\n                        attributes: attributes,\r\n                    };\r\n                })\r\n                    .filter((attribute) => !addedIds.has(attribute.id))\r\n                    .filter((attribute) => this.mirror.has(attribute.id)),\r\n                removes: this.removes,\r\n                adds,\r\n            };\r\n            if (!payload.texts.length &&\r\n                !payload.attributes.length &&\r\n                !payload.removes.length &&\r\n                !payload.adds.length) {\r\n                return;\r\n            }\r\n            this.texts = [];\r\n            this.attributes = [];\r\n            this.attributeMap = new WeakMap();\r\n            this.removes = [];\r\n            this.addedSet = new Set();\r\n            this.movedSet = new Set();\r\n            this.droppedSet = new Set();\r\n            this.movedMap = {};\r\n            this.mutationCb(payload);\r\n        };\r\n        this.processMutation = (m) => {\r\n            if (isIgnored(m.target, this.mirror)) {\r\n                return;\r\n            }\r\n            switch (m.type) {\r\n                case 'characterData': {\r\n                    const value = m.target.textContent;\r\n                    if (!isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, false) &&\r\n                        value !== m.oldValue) {\r\n                        this.texts.push({\r\n                            value: needMaskingText(m.target, this.maskTextClass, this.maskTextSelector, this.unmaskTextClass, this.unmaskTextSelector, this.maskAllText) && value\r\n                                ? this.maskTextFn\r\n                                    ? this.maskTextFn(value, closestElementOfNode(m.target))\r\n                                    : value.replace(/[\\S]/g, '*')\r\n                                : value,\r\n                            node: m.target,\r\n                        });\r\n                    }\r\n                    break;\r\n                }\r\n                case 'attributes': {\r\n                    const target = m.target;\r\n                    let attributeName = m.attributeName;\r\n                    let value = m.target.getAttribute(attributeName);\r\n                    if (attributeName === 'value') {\r\n                        const type = getInputType(target);\r\n                        const tagName = target.tagName;\r\n                        value = getInputValue(target, tagName, type);\r\n                        const isInputMasked = shouldMaskInput({\r\n                            maskInputOptions: this.maskInputOptions,\r\n                            tagName,\r\n                            type,\r\n                        });\r\n                        const forceMask = needMaskingText(m.target, this.maskTextClass, this.maskTextSelector, this.unmaskTextClass, this.unmaskTextSelector, isInputMasked);\r\n                        value = maskInputValue({\r\n                            isMasked: forceMask,\r\n                            element: target,\r\n                            value,\r\n                            maskInputFn: this.maskInputFn,\r\n                        });\r\n                    }\r\n                    if (isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, false) ||\r\n                        value === m.oldValue) {\r\n                        return;\r\n                    }\r\n                    let item = this.attributeMap.get(m.target);\r\n                    if (target.tagName === 'IFRAME' &&\r\n                        attributeName === 'src' &&\r\n                        !this.keepIframeSrcFn(value)) {\r\n                        if (!target.contentDocument) {\r\n                            attributeName = 'rr_src';\r\n                        }\r\n                        else {\r\n                            return;\r\n                        }\r\n                    }\r\n                    if (!item) {\r\n                        item = {\r\n                            node: m.target,\r\n                            attributes: {},\r\n                            styleDiff: {},\r\n                            _unchangedStyles: {},\r\n                        };\r\n                        this.attributes.push(item);\r\n                        this.attributeMap.set(m.target, item);\r\n                    }\r\n                    if (attributeName === 'type' &&\r\n                        target.tagName === 'INPUT' &&\r\n                        (m.oldValue || '').toLowerCase() === 'password') {\r\n                        target.setAttribute('data-rr-is-password', 'true');\r\n                    }\r\n                    if (!ignoreAttribute(target.tagName, attributeName)) {\r\n                        item.attributes[attributeName] = transformAttribute(this.doc, toLowerCase(target.tagName), toLowerCase(attributeName), value, target, this.maskAttributeFn);\r\n                        if (attributeName === 'style') {\r\n                            if (!this.unattachedDoc) {\r\n                                try {\r\n                                    this.unattachedDoc =\r\n                                        document.implementation.createHTMLDocument();\r\n                                }\r\n                                catch (e) {\r\n                                    this.unattachedDoc = this.doc;\r\n                                }\r\n                            }\r\n                            const old = this.unattachedDoc.createElement('span');\r\n                            if (m.oldValue) {\r\n                                old.setAttribute('style', m.oldValue);\r\n                            }\r\n                            for (const pname of Array.from(target.style)) {\r\n                                const newValue = target.style.getPropertyValue(pname);\r\n                                const newPriority = target.style.getPropertyPriority(pname);\r\n                                if (newValue !== old.style.getPropertyValue(pname) ||\r\n                                    newPriority !== old.style.getPropertyPriority(pname)) {\r\n                                    if (newPriority === '') {\r\n                                        item.styleDiff[pname] = newValue;\r\n                                    }\r\n                                    else {\r\n                                        item.styleDiff[pname] = [newValue, newPriority];\r\n                                    }\r\n                                }\r\n                                else {\r\n                                    item._unchangedStyles[pname] = [newValue, newPriority];\r\n                                }\r\n                            }\r\n                            for (const pname of Array.from(old.style)) {\r\n                                if (target.style.getPropertyValue(pname) === '') {\r\n                                    item.styleDiff[pname] = false;\r\n                                }\r\n                            }\r\n                        }\r\n                    }\r\n                    break;\r\n                }\r\n                case 'childList': {\r\n                    if (isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, true)) {\r\n                        return;\r\n                    }\r\n                    m.addedNodes.forEach((n) => this.genAdds(n, m.target));\r\n                    m.removedNodes.forEach((n) => {\r\n                        const nodeId = this.mirror.getId(n);\r\n                        const parentId = isShadowRoot(m.target)\r\n                            ? this.mirror.getId(m.target.host)\r\n                            : this.mirror.getId(m.target);\r\n                        if (isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, false) ||\r\n                            isIgnored(n, this.mirror) ||\r\n                            !isSerialized(n, this.mirror)) {\r\n                            return;\r\n                        }\r\n                        if (this.addedSet.has(n)) {\r\n                            deepDelete(this.addedSet, n);\r\n                            this.droppedSet.add(n);\r\n                        }\r\n                        else if (this.addedSet.has(m.target) && nodeId === -1) ;\r\n                        else if (isAncestorRemoved(m.target, this.mirror)) ;\r\n                        else if (this.movedSet.has(n) &&\r\n                            this.movedMap[moveKey(nodeId, parentId)]) {\r\n                            deepDelete(this.movedSet, n);\r\n                        }\r\n                        else {\r\n                            this.removes.push({\r\n                                parentId,\r\n                                id: nodeId,\r\n                                isShadow: isShadowRoot(m.target) && isNativeShadowDom(m.target)\r\n                                    ? true\r\n                                    : undefined,\r\n                            });\r\n                        }\r\n                        this.mapRemoves.push(n);\r\n                    });\r\n                    break;\r\n                }\r\n            }\r\n        };\r\n        this.genAdds = (n, target) => {\r\n            if (this.processedNodeManager.inOtherBuffer(n, this))\r\n                return;\r\n            if (this.addedSet.has(n) || this.movedSet.has(n))\r\n                return;\r\n            if (this.mirror.hasNode(n)) {\r\n                if (isIgnored(n, this.mirror)) {\r\n                    return;\r\n                }\r\n                this.movedSet.add(n);\r\n                let targetId = null;\r\n                if (target && this.mirror.hasNode(target)) {\r\n                    targetId = this.mirror.getId(target);\r\n                }\r\n                if (targetId && targetId !== -1) {\r\n                    this.movedMap[moveKey(this.mirror.getId(n), targetId)] = true;\r\n                }\r\n            }\r\n            else {\r\n                this.addedSet.add(n);\r\n                this.droppedSet.delete(n);\r\n            }\r\n            if (!isBlocked(n, this.blockClass, this.blockSelector, this.unblockSelector, false)) {\r\n                n.childNodes.forEach((childN) => this.genAdds(childN));\r\n                if (hasShadowRoot(n)) {\r\n                    n.shadowRoot.childNodes.forEach((childN) => {\r\n                        this.processedNodeManager.add(childN, this);\r\n                        this.genAdds(childN, n);\r\n                    });\r\n                }\r\n            }\r\n        };\r\n    }\r\n    init(options) {\r\n        [\r\n            'mutationCb',\r\n            'blockClass',\r\n            'blockSelector',\r\n            'unblockSelector',\r\n            'maskAllText',\r\n            'maskTextClass',\r\n            'unmaskTextClass',\r\n            'maskTextSelector',\r\n            'unmaskTextSelector',\r\n            'inlineStylesheet',\r\n            'maskInputOptions',\r\n            'maskAttributeFn',\r\n            'maskTextFn',\r\n            'maskInputFn',\r\n            'keepIframeSrcFn',\r\n            'recordCanvas',\r\n            'inlineImages',\r\n            'slimDOMOptions',\r\n            'dataURLOptions',\r\n            'doc',\r\n            'mirror',\r\n            'iframeManager',\r\n            'stylesheetManager',\r\n            'shadowDomManager',\r\n            'canvasManager',\r\n            'processedNodeManager',\r\n        ].forEach((key) => {\r\n            this[key] = options[key];\r\n        });\r\n    }\r\n    freeze() {\r\n        this.frozen = true;\r\n        this.canvasManager.freeze();\r\n    }\r\n    unfreeze() {\r\n        this.frozen = false;\r\n        this.canvasManager.unfreeze();\r\n        this.emit();\r\n    }\r\n    isFrozen() {\r\n        return this.frozen;\r\n    }\r\n    lock() {\r\n        this.locked = true;\r\n        this.canvasManager.lock();\r\n    }\r\n    unlock() {\r\n        this.locked = false;\r\n        this.canvasManager.unlock();\r\n        this.emit();\r\n    }\r\n    reset() {\r\n        this.shadowDomManager.reset();\r\n        this.canvasManager.reset();\r\n    }\r\n}\r\nfunction deepDelete(addsSet, n) {\r\n    addsSet.delete(n);\r\n    n.childNodes.forEach((childN) => deepDelete(addsSet, childN));\r\n}\r\nfunction isParentRemoved(removes, n, mirror) {\r\n    if (removes.length === 0)\r\n        return false;\r\n    return _isParentRemoved(removes, n, mirror);\r\n}\r\nfunction _isParentRemoved(removes, n, mirror) {\r\n    const { parentNode } = n;\r\n    if (!parentNode) {\r\n        return false;\r\n    }\r\n    const parentId = mirror.getId(parentNode);\r\n    if (removes.some((r) => r.id === parentId)) {\r\n        return true;\r\n    }\r\n    return _isParentRemoved(removes, parentNode, mirror);\r\n}\r\nfunction isAncestorInSet(set, n) {\r\n    if (set.size === 0)\r\n        return false;\r\n    return _isAncestorInSet(set, n);\r\n}\r\nfunction _isAncestorInSet(set, n) {\r\n    const { parentNode } = n;\r\n    if (!parentNode) {\r\n        return false;\r\n    }\r\n    if (set.has(parentNode)) {\r\n        return true;\r\n    }\r\n    return _isAncestorInSet(set, parentNode);\r\n}\n\nexport { MutationBuffer as default };\n","let errorHandler;\r\nfunction registerErrorHandler(handler) {\r\n    errorHandler = handler;\r\n}\r\nfunction unregisterErrorHandler() {\r\n    errorHandler = undefined;\r\n}\r\nconst callbackWrapper = (cb) => {\r\n    if (!errorHandler) {\r\n        return cb;\r\n    }\r\n    const rrwebWrapped = ((...rest) => {\r\n        try {\r\n            return cb(...rest);\r\n        }\r\n        catch (error) {\r\n            if (errorHandler && errorHandler(error) === true) {\r\n                return () => {\r\n                };\r\n            }\r\n            throw error;\r\n        }\r\n    });\r\n    return rrwebWrapped;\r\n};\n\nexport { callbackWrapper, registerErrorHandler, unregisterErrorHandler };\n","import { toLowerCase, toUpperCase, getInputType, getInputValue, shouldMaskInput, needMaskingText, maskInputValue } from '../../../rrweb-snapshot/es/rrweb-snapshot.js';\nimport { on, throttle, isBlocked, getWindowScroll, hookSetter, patch, setTimeout, legacy_isTouchEvent, nowTimestamp, getWindowHeight, getWindowWidth } from '../utils.js';\nimport { MouseInteractions, IncrementalSource, PointerTypes } from '../../../types/dist/rrweb-types.js';\nimport MutationBuffer from './mutation.js';\nimport { callbackWrapper } from './error-handler.js';\n\nconst mutationBuffers = [];\r\nfunction getEventTarget(event) {\r\n    try {\r\n        if ('composedPath' in event) {\r\n            const path = event.composedPath();\r\n            if (path.length) {\r\n                return path[0];\r\n            }\r\n        }\r\n        else if ('path' in event && event.path.length) {\r\n            return event.path[0];\r\n        }\r\n    }\r\n    catch {\r\n    }\r\n    return event && event.target;\r\n}\r\nfunction initMutationObserver(options, rootEl) {\r\n    const mutationBuffer = new MutationBuffer();\r\n    mutationBuffers.push(mutationBuffer);\r\n    mutationBuffer.init(options);\r\n    let mutationObserverCtor = window.MutationObserver ||\r\n        window.__rrMutationObserver;\r\n    const angularZoneSymbol = window?.Zone?.__symbol__?.('MutationObserver');\r\n    if (angularZoneSymbol &&\r\n        window[angularZoneSymbol]) {\r\n        mutationObserverCtor = window[angularZoneSymbol];\r\n    }\r\n    const observer = new mutationObserverCtor(callbackWrapper((mutations) => {\r\n        if (options.onMutation && options.onMutation(mutations) === false) {\r\n            return;\r\n        }\r\n        mutationBuffer.processMutations.bind(mutationBuffer)(mutations);\r\n    }));\r\n    observer.observe(rootEl, {\r\n        attributes: true,\r\n        attributeOldValue: true,\r\n        characterData: true,\r\n        characterDataOldValue: true,\r\n        childList: true,\r\n        subtree: true,\r\n    });\r\n    return observer;\r\n}\r\nfunction initMoveObserver({ mousemoveCb, sampling, doc, mirror, }) {\r\n    if (sampling.mousemove === false) {\r\n        return () => {\r\n        };\r\n    }\r\n    const threshold = typeof sampling.mousemove === 'number' ? sampling.mousemove : 50;\r\n    const callbackThreshold = typeof sampling.mousemoveCallback === 'number'\r\n        ? sampling.mousemoveCallback\r\n        : 500;\r\n    let positions = [];\r\n    let timeBaseline;\r\n    const wrappedCb = throttle(callbackWrapper((source) => {\r\n        const totalOffset = Date.now() - timeBaseline;\r\n        mousemoveCb(positions.map((p) => {\r\n            p.timeOffset -= totalOffset;\r\n            return p;\r\n        }), source);\r\n        positions = [];\r\n        timeBaseline = null;\r\n    }), callbackThreshold);\r\n    const updatePosition = callbackWrapper(throttle(callbackWrapper((evt) => {\r\n        const target = getEventTarget(evt);\r\n        const { clientX, clientY } = legacy_isTouchEvent(evt)\r\n            ? evt.changedTouches[0]\r\n            : evt;\r\n        if (!timeBaseline) {\r\n            timeBaseline = nowTimestamp();\r\n        }\r\n        positions.push({\r\n            x: clientX,\r\n            y: clientY,\r\n            id: mirror.getId(target),\r\n            timeOffset: nowTimestamp() - timeBaseline,\r\n        });\r\n        wrappedCb(typeof DragEvent !== 'undefined' && evt instanceof DragEvent\r\n            ? IncrementalSource.Drag\r\n            : evt instanceof MouseEvent\r\n                ? IncrementalSource.MouseMove\r\n                : IncrementalSource.TouchMove);\r\n    }), threshold, {\r\n        trailing: false,\r\n    }));\r\n    const handlers = [\r\n        on('mousemove', updatePosition, doc),\r\n        on('touchmove', updatePosition, doc),\r\n        on('drag', updatePosition, doc),\r\n    ];\r\n    return callbackWrapper(() => {\r\n        handlers.forEach((h) => h());\r\n    });\r\n}\r\nfunction initMouseInteractionObserver({ mouseInteractionCb, doc, mirror, blockClass, blockSelector, unblockSelector, sampling, }) {\r\n    if (sampling.mouseInteraction === false) {\r\n        return () => {\r\n        };\r\n    }\r\n    const disableMap = sampling.mouseInteraction === true ||\r\n        sampling.mouseInteraction === undefined\r\n        ? {}\r\n        : sampling.mouseInteraction;\r\n    const handlers = [];\r\n    let currentPointerType = null;\r\n    const getHandler = (eventKey) => {\r\n        return (event) => {\r\n            const target = getEventTarget(event);\r\n            if (isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\r\n                return;\r\n            }\r\n            let pointerType = null;\r\n            let thisEventKey = eventKey;\r\n            if ('pointerType' in event) {\r\n                switch (event.pointerType) {\r\n                    case 'mouse':\r\n                        pointerType = PointerTypes.Mouse;\r\n                        break;\r\n                    case 'touch':\r\n                        pointerType = PointerTypes.Touch;\r\n                        break;\r\n                    case 'pen':\r\n                        pointerType = PointerTypes.Pen;\r\n                        break;\r\n                }\r\n                if (pointerType === PointerTypes.Touch) {\r\n                    if (MouseInteractions[eventKey] === MouseInteractions.MouseDown) {\r\n                        thisEventKey = 'TouchStart';\r\n                    }\r\n                    else if (MouseInteractions[eventKey] === MouseInteractions.MouseUp) {\r\n                        thisEventKey = 'TouchEnd';\r\n                    }\r\n                }\r\n                else if (pointerType === PointerTypes.Pen) ;\r\n            }\r\n            else if (legacy_isTouchEvent(event)) {\r\n                pointerType = PointerTypes.Touch;\r\n            }\r\n            if (pointerType !== null) {\r\n                currentPointerType = pointerType;\r\n                if ((thisEventKey.startsWith('Touch') &&\r\n                    pointerType === PointerTypes.Touch) ||\r\n                    (thisEventKey.startsWith('Mouse') &&\r\n                        pointerType === PointerTypes.Mouse)) {\r\n                    pointerType = null;\r\n                }\r\n            }\r\n            else if (MouseInteractions[eventKey] === MouseInteractions.Click) {\r\n                pointerType = currentPointerType;\r\n                currentPointerType = null;\r\n            }\r\n            const e = legacy_isTouchEvent(event) ? event.changedTouches[0] : event;\r\n            if (!e) {\r\n                return;\r\n            }\r\n            const id = mirror.getId(target);\r\n            const { clientX, clientY } = e;\r\n            callbackWrapper(mouseInteractionCb)({\r\n                type: MouseInteractions[thisEventKey],\r\n                id,\r\n                x: clientX,\r\n                y: clientY,\r\n                ...(pointerType !== null && { pointerType }),\r\n            });\r\n        };\r\n    };\r\n    Object.keys(MouseInteractions)\r\n        .filter((key) => Number.isNaN(Number(key)) &&\r\n        !key.endsWith('_Departed') &&\r\n        disableMap[key] !== false)\r\n        .forEach((eventKey) => {\r\n        let eventName = toLowerCase(eventKey);\r\n        const handler = getHandler(eventKey);\r\n        if (window.PointerEvent) {\r\n            switch (MouseInteractions[eventKey]) {\r\n                case MouseInteractions.MouseDown:\r\n                case MouseInteractions.MouseUp:\r\n                    eventName = eventName.replace('mouse', 'pointer');\r\n                    break;\r\n                case MouseInteractions.TouchStart:\r\n                case MouseInteractions.TouchEnd:\r\n                    return;\r\n            }\r\n        }\r\n        handlers.push(on(eventName, handler, doc));\r\n    });\r\n    return callbackWrapper(() => {\r\n        handlers.forEach((h) => h());\r\n    });\r\n}\r\nfunction initScrollObserver({ scrollCb, doc, mirror, blockClass, blockSelector, unblockSelector, sampling, }) {\r\n    const updatePosition = callbackWrapper(throttle(callbackWrapper((evt) => {\r\n        const target = getEventTarget(evt);\r\n        if (!target ||\r\n            isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\r\n            return;\r\n        }\r\n        const id = mirror.getId(target);\r\n        if (target === doc && doc.defaultView) {\r\n            const scrollLeftTop = getWindowScroll(doc.defaultView);\r\n            scrollCb({\r\n                id,\r\n                x: scrollLeftTop.left,\r\n                y: scrollLeftTop.top,\r\n            });\r\n        }\r\n        else {\r\n            scrollCb({\r\n                id,\r\n                x: target.scrollLeft,\r\n                y: target.scrollTop,\r\n            });\r\n        }\r\n    }), sampling.scroll || 100));\r\n    return on('scroll', updatePosition, doc);\r\n}\r\nfunction initViewportResizeObserver({ viewportResizeCb }, { win }) {\r\n    let lastH = -1;\r\n    let lastW = -1;\r\n    const updateDimension = callbackWrapper(throttle(callbackWrapper(() => {\r\n        const height = getWindowHeight();\r\n        const width = getWindowWidth();\r\n        if (lastH !== height || lastW !== width) {\r\n            viewportResizeCb({\r\n                width: Number(width),\r\n                height: Number(height),\r\n            });\r\n            lastH = height;\r\n            lastW = width;\r\n        }\r\n    }), 200));\r\n    return on('resize', updateDimension, win);\r\n}\r\nconst INPUT_TAGS = ['INPUT', 'TEXTAREA', 'SELECT'];\r\nconst lastInputValueMap = new WeakMap();\r\nfunction initInputObserver({ inputCb, doc, mirror, blockClass, blockSelector, unblockSelector, ignoreClass, ignoreSelector, maskInputOptions, maskInputFn, sampling, userTriggeredOnInput, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, }) {\r\n    function eventHandler(event) {\r\n        let target = getEventTarget(event);\r\n        const userTriggered = event.isTrusted;\r\n        const tagName = target && toUpperCase(target.tagName);\r\n        if (tagName === 'OPTION')\r\n            target = target.parentElement;\r\n        if (!target ||\r\n            !tagName ||\r\n            INPUT_TAGS.indexOf(tagName) < 0 ||\r\n            isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\r\n            return;\r\n        }\r\n        const el = target;\r\n        if (el.classList.contains(ignoreClass) ||\r\n            (ignoreSelector && el.matches(ignoreSelector))) {\r\n            return;\r\n        }\r\n        const type = getInputType(target);\r\n        let text = getInputValue(el, tagName, type);\r\n        let isChecked = false;\r\n        const isInputMasked = shouldMaskInput({\r\n            maskInputOptions,\r\n            tagName,\r\n            type,\r\n        });\r\n        const forceMask = needMaskingText(target, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, isInputMasked);\r\n        if (type === 'radio' || type === 'checkbox') {\r\n            isChecked = target.checked;\r\n        }\r\n        text = maskInputValue({\r\n            isMasked: forceMask,\r\n            element: target,\r\n            value: text,\r\n            maskInputFn,\r\n        });\r\n        cbWithDedup(target, userTriggeredOnInput\r\n            ? { text, isChecked, userTriggered }\r\n            : { text, isChecked });\r\n        const name = target.name;\r\n        if (type === 'radio' && name && isChecked) {\r\n            doc\r\n                .querySelectorAll(`input[type=\"radio\"][name=\"${name}\"]`)\r\n                .forEach((el) => {\r\n                if (el !== target) {\r\n                    const text = maskInputValue({\r\n                        isMasked: forceMask,\r\n                        element: el,\r\n                        value: getInputValue(el, tagName, type),\r\n                        maskInputFn,\r\n                    });\r\n                    cbWithDedup(el, userTriggeredOnInput\r\n                        ? { text, isChecked: !isChecked, userTriggered: false }\r\n                        : { text, isChecked: !isChecked });\r\n                }\r\n            });\r\n        }\r\n    }\r\n    function cbWithDedup(target, v) {\r\n        const lastInputValue = lastInputValueMap.get(target);\r\n        if (!lastInputValue ||\r\n            lastInputValue.text !== v.text ||\r\n            lastInputValue.isChecked !== v.isChecked) {\r\n            lastInputValueMap.set(target, v);\r\n            const id = mirror.getId(target);\r\n            callbackWrapper(inputCb)({\r\n                ...v,\r\n                id,\r\n            });\r\n        }\r\n    }\r\n    const events = sampling.input === 'last' ? ['change'] : ['input', 'change'];\r\n    const handlers = events.map((eventName) => on(eventName, callbackWrapper(eventHandler), doc));\r\n    const currentWindow = doc.defaultView;\r\n    if (!currentWindow) {\r\n        return () => {\r\n            handlers.forEach((h) => h());\r\n        };\r\n    }\r\n    const propertyDescriptor = currentWindow.Object.getOwnPropertyDescriptor(currentWindow.HTMLInputElement.prototype, 'value');\r\n    const hookProperties = [\r\n        [currentWindow.HTMLInputElement.prototype, 'value'],\r\n        [currentWindow.HTMLInputElement.prototype, 'checked'],\r\n        [currentWindow.HTMLSelectElement.prototype, 'value'],\r\n        [currentWindow.HTMLTextAreaElement.prototype, 'value'],\r\n        [currentWindow.HTMLSelectElement.prototype, 'selectedIndex'],\r\n        [currentWindow.HTMLOptionElement.prototype, 'selected'],\r\n    ];\r\n    if (propertyDescriptor && propertyDescriptor.set) {\r\n        handlers.push(...hookProperties.map((p) => hookSetter(p[0], p[1], {\r\n            set() {\r\n                callbackWrapper(eventHandler)({\r\n                    target: this,\r\n                    isTrusted: false,\r\n                });\r\n            },\r\n        }, false, currentWindow)));\r\n    }\r\n    return callbackWrapper(() => {\r\n        handlers.forEach((h) => h());\r\n    });\r\n}\r\nfunction getNestedCSSRulePositions(rule) {\r\n    const positions = [];\r\n    function recurse(childRule, pos) {\r\n        if ((hasNestedCSSRule('CSSGroupingRule') &&\r\n            childRule.parentRule instanceof CSSGroupingRule) ||\r\n            (hasNestedCSSRule('CSSMediaRule') &&\r\n                childRule.parentRule instanceof CSSMediaRule) ||\r\n            (hasNestedCSSRule('CSSSupportsRule') &&\r\n                childRule.parentRule instanceof CSSSupportsRule) ||\r\n            (hasNestedCSSRule('CSSConditionRule') &&\r\n                childRule.parentRule instanceof CSSConditionRule)) {\r\n            const rules = Array.from(childRule.parentRule.cssRules);\r\n            const index = rules.indexOf(childRule);\r\n            pos.unshift(index);\r\n        }\r\n        else if (childRule.parentStyleSheet) {\r\n            const rules = Array.from(childRule.parentStyleSheet.cssRules);\r\n            const index = rules.indexOf(childRule);\r\n            pos.unshift(index);\r\n        }\r\n        return pos;\r\n    }\r\n    return recurse(rule, positions);\r\n}\r\nfunction getIdAndStyleId(sheet, mirror, styleMirror) {\r\n    let id, styleId;\r\n    if (!sheet)\r\n        return {};\r\n    if (sheet.ownerNode)\r\n        id = mirror.getId(sheet.ownerNode);\r\n    else\r\n        styleId = styleMirror.getId(sheet);\r\n    return {\r\n        styleId,\r\n        id,\r\n    };\r\n}\r\nfunction initStyleSheetObserver({ styleSheetRuleCb, mirror, stylesheetManager }, { win }) {\r\n    if (!win.CSSStyleSheet || !win.CSSStyleSheet.prototype) {\r\n        return () => {\r\n        };\r\n    }\r\n    const insertRule = win.CSSStyleSheet.prototype.insertRule;\r\n    win.CSSStyleSheet.prototype.insertRule = new Proxy(insertRule, {\r\n        apply: callbackWrapper((target, thisArg, argumentsList) => {\r\n            const [rule, index] = argumentsList;\r\n            const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\r\n            if ((id && id !== -1) || (styleId && styleId !== -1)) {\r\n                styleSheetRuleCb({\r\n                    id,\r\n                    styleId,\r\n                    adds: [{ rule, index }],\r\n                });\r\n            }\r\n            return target.apply(thisArg, argumentsList);\r\n        }),\r\n    });\r\n    const deleteRule = win.CSSStyleSheet.prototype.deleteRule;\r\n    win.CSSStyleSheet.prototype.deleteRule = new Proxy(deleteRule, {\r\n        apply: callbackWrapper((target, thisArg, argumentsList) => {\r\n            const [index] = argumentsList;\r\n            const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\r\n            if ((id && id !== -1) || (styleId && styleId !== -1)) {\r\n                styleSheetRuleCb({\r\n                    id,\r\n                    styleId,\r\n                    removes: [{ index }],\r\n                });\r\n            }\r\n            return target.apply(thisArg, argumentsList);\r\n        }),\r\n    });\r\n    let replace;\r\n    if (win.CSSStyleSheet.prototype.replace) {\r\n        replace = win.CSSStyleSheet.prototype.replace;\r\n        win.CSSStyleSheet.prototype.replace = new Proxy(replace, {\r\n            apply: callbackWrapper((target, thisArg, argumentsList) => {\r\n                const [text] = argumentsList;\r\n                const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\r\n                if ((id && id !== -1) || (styleId && styleId !== -1)) {\r\n                    styleSheetRuleCb({\r\n                        id,\r\n                        styleId,\r\n                        replace: text,\r\n                    });\r\n                }\r\n                return target.apply(thisArg, argumentsList);\r\n            }),\r\n        });\r\n    }\r\n    let replaceSync;\r\n    if (win.CSSStyleSheet.prototype.replaceSync) {\r\n        replaceSync = win.CSSStyleSheet.prototype.replaceSync;\r\n        win.CSSStyleSheet.prototype.replaceSync = new Proxy(replaceSync, {\r\n            apply: callbackWrapper((target, thisArg, argumentsList) => {\r\n                const [text] = argumentsList;\r\n                const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\r\n                if ((id && id !== -1) || (styleId && styleId !== -1)) {\r\n                    styleSheetRuleCb({\r\n                        id,\r\n                        styleId,\r\n                        replaceSync: text,\r\n                    });\r\n                }\r\n                return target.apply(thisArg, argumentsList);\r\n            }),\r\n        });\r\n    }\r\n    const supportedNestedCSSRuleTypes = {};\r\n    if (canMonkeyPatchNestedCSSRule('CSSGroupingRule')) {\r\n        supportedNestedCSSRuleTypes.CSSGroupingRule = win.CSSGroupingRule;\r\n    }\r\n    else {\r\n        if (canMonkeyPatchNestedCSSRule('CSSMediaRule')) {\r\n            supportedNestedCSSRuleTypes.CSSMediaRule = win.CSSMediaRule;\r\n        }\r\n        if (canMonkeyPatchNestedCSSRule('CSSConditionRule')) {\r\n            supportedNestedCSSRuleTypes.CSSConditionRule = win.CSSConditionRule;\r\n        }\r\n        if (canMonkeyPatchNestedCSSRule('CSSSupportsRule')) {\r\n            supportedNestedCSSRuleTypes.CSSSupportsRule = win.CSSSupportsRule;\r\n        }\r\n    }\r\n    const unmodifiedFunctions = {};\r\n    Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {\r\n        unmodifiedFunctions[typeKey] = {\r\n            insertRule: type.prototype.insertRule,\r\n            deleteRule: type.prototype.deleteRule,\r\n        };\r\n        type.prototype.insertRule = new Proxy(unmodifiedFunctions[typeKey].insertRule, {\r\n            apply: callbackWrapper((target, thisArg, argumentsList) => {\r\n                const [rule, index] = argumentsList;\r\n                const { id, styleId } = getIdAndStyleId(thisArg.parentStyleSheet, mirror, stylesheetManager.styleMirror);\r\n                if ((id && id !== -1) || (styleId && styleId !== -1)) {\r\n                    styleSheetRuleCb({\r\n                        id,\r\n                        styleId,\r\n                        adds: [\r\n                            {\r\n                                rule,\r\n                                index: [\r\n                                    ...getNestedCSSRulePositions(thisArg),\r\n                                    index || 0,\r\n                                ],\r\n                            },\r\n                        ],\r\n                    });\r\n                }\r\n                return target.apply(thisArg, argumentsList);\r\n            }),\r\n        });\r\n        type.prototype.deleteRule = new Proxy(unmodifiedFunctions[typeKey].deleteRule, {\r\n            apply: callbackWrapper((target, thisArg, argumentsList) => {\r\n                const [index] = argumentsList;\r\n                const { id, styleId } = getIdAndStyleId(thisArg.parentStyleSheet, mirror, stylesheetManager.styleMirror);\r\n                if ((id && id !== -1) || (styleId && styleId !== -1)) {\r\n                    styleSheetRuleCb({\r\n                        id,\r\n                        styleId,\r\n                        removes: [\r\n                            { index: [...getNestedCSSRulePositions(thisArg), index] },\r\n                        ],\r\n                    });\r\n                }\r\n                return target.apply(thisArg, argumentsList);\r\n            }),\r\n        });\r\n    });\r\n    return callbackWrapper(() => {\r\n        win.CSSStyleSheet.prototype.insertRule = insertRule;\r\n        win.CSSStyleSheet.prototype.deleteRule = deleteRule;\r\n        replace && (win.CSSStyleSheet.prototype.replace = replace);\r\n        replaceSync && (win.CSSStyleSheet.prototype.replaceSync = replaceSync);\r\n        Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {\r\n            type.prototype.insertRule = unmodifiedFunctions[typeKey].insertRule;\r\n            type.prototype.deleteRule = unmodifiedFunctions[typeKey].deleteRule;\r\n        });\r\n    });\r\n}\r\nfunction initAdoptedStyleSheetObserver({ mirror, stylesheetManager, }, host) {\r\n    let hostId = null;\r\n    if (host.nodeName === '#document')\r\n        hostId = mirror.getId(host);\r\n    else\r\n        hostId = mirror.getId(host.host);\r\n    const patchTarget = host.nodeName === '#document'\r\n        ? host.defaultView?.Document\r\n        : host.ownerDocument?.defaultView?.ShadowRoot;\r\n    const originalPropertyDescriptor = patchTarget?.prototype\r\n        ? Object.getOwnPropertyDescriptor(patchTarget?.prototype, 'adoptedStyleSheets')\r\n        : undefined;\r\n    if (hostId === null ||\r\n        hostId === -1 ||\r\n        !patchTarget ||\r\n        !originalPropertyDescriptor)\r\n        return () => {\r\n        };\r\n    Object.defineProperty(host, 'adoptedStyleSheets', {\r\n        configurable: originalPropertyDescriptor.configurable,\r\n        enumerable: originalPropertyDescriptor.enumerable,\r\n        get() {\r\n            return originalPropertyDescriptor.get?.call(this);\r\n        },\r\n        set(sheets) {\r\n            const result = originalPropertyDescriptor.set?.call(this, sheets);\r\n            if (hostId !== null && hostId !== -1) {\r\n                try {\r\n                    stylesheetManager.adoptStyleSheets(sheets, hostId);\r\n                }\r\n                catch (e) {\r\n                }\r\n            }\r\n            return result;\r\n        },\r\n    });\r\n    return callbackWrapper(() => {\r\n        Object.defineProperty(host, 'adoptedStyleSheets', {\r\n            configurable: originalPropertyDescriptor.configurable,\r\n            enumerable: originalPropertyDescriptor.enumerable,\r\n            get: originalPropertyDescriptor.get,\r\n            set: originalPropertyDescriptor.set,\r\n        });\r\n    });\r\n}\r\nfunction initStyleDeclarationObserver({ styleDeclarationCb, mirror, ignoreCSSAttributes, stylesheetManager, }, { win }) {\r\n    const setProperty = win.CSSStyleDeclaration.prototype.setProperty;\r\n    win.CSSStyleDeclaration.prototype.setProperty = new Proxy(setProperty, {\r\n        apply: callbackWrapper((target, thisArg, argumentsList) => {\r\n            const [property, value, priority] = argumentsList;\r\n            if (ignoreCSSAttributes.has(property)) {\r\n                return setProperty.apply(thisArg, [property, value, priority]);\r\n            }\r\n            const { id, styleId } = getIdAndStyleId(thisArg.parentRule?.parentStyleSheet, mirror, stylesheetManager.styleMirror);\r\n            if ((id && id !== -1) || (styleId && styleId !== -1)) {\r\n                styleDeclarationCb({\r\n                    id,\r\n                    styleId,\r\n                    set: {\r\n                        property,\r\n                        value,\r\n                        priority,\r\n                    },\r\n                    index: getNestedCSSRulePositions(thisArg.parentRule),\r\n                });\r\n            }\r\n            return target.apply(thisArg, argumentsList);\r\n        }),\r\n    });\r\n    const removeProperty = win.CSSStyleDeclaration.prototype.removeProperty;\r\n    win.CSSStyleDeclaration.prototype.removeProperty = new Proxy(removeProperty, {\r\n        apply: callbackWrapper((target, thisArg, argumentsList) => {\r\n            const [property] = argumentsList;\r\n            if (ignoreCSSAttributes.has(property)) {\r\n                return removeProperty.apply(thisArg, [property]);\r\n            }\r\n            const { id, styleId } = getIdAndStyleId(thisArg.parentRule?.parentStyleSheet, mirror, stylesheetManager.styleMirror);\r\n            if ((id && id !== -1) || (styleId && styleId !== -1)) {\r\n                styleDeclarationCb({\r\n                    id,\r\n                    styleId,\r\n                    remove: {\r\n                        property,\r\n                    },\r\n                    index: getNestedCSSRulePositions(thisArg.parentRule),\r\n                });\r\n            }\r\n            return target.apply(thisArg, argumentsList);\r\n        }),\r\n    });\r\n    return callbackWrapper(() => {\r\n        win.CSSStyleDeclaration.prototype.setProperty = setProperty;\r\n        win.CSSStyleDeclaration.prototype.removeProperty = removeProperty;\r\n    });\r\n}\r\nfunction initMediaInteractionObserver({ mediaInteractionCb, blockClass, blockSelector, unblockSelector, mirror, sampling, doc, }) {\r\n    const handler = callbackWrapper((type) => throttle(callbackWrapper((event) => {\r\n        const target = getEventTarget(event);\r\n        if (!target ||\r\n            isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\r\n            return;\r\n        }\r\n        const { currentTime, volume, muted, playbackRate } = target;\r\n        mediaInteractionCb({\r\n            type,\r\n            id: mirror.getId(target),\r\n            currentTime,\r\n            volume,\r\n            muted,\r\n            playbackRate,\r\n        });\r\n    }), sampling.media || 500));\r\n    const handlers = [\r\n        on('play', handler(0), doc),\r\n        on('pause', handler(1), doc),\r\n        on('seeked', handler(2), doc),\r\n        on('volumechange', handler(3), doc),\r\n        on('ratechange', handler(4), doc),\r\n    ];\r\n    return callbackWrapper(() => {\r\n        handlers.forEach((h) => h());\r\n    });\r\n}\r\nfunction initFontObserver({ fontCb, doc }) {\r\n    const win = doc.defaultView;\r\n    if (!win) {\r\n        return () => {\r\n        };\r\n    }\r\n    const handlers = [];\r\n    const fontMap = new WeakMap();\r\n    const originalFontFace = win.FontFace;\r\n    win.FontFace = function FontFace(family, source, descriptors) {\r\n        const fontFace = new originalFontFace(family, source, descriptors);\r\n        fontMap.set(fontFace, {\r\n            family,\r\n            buffer: typeof source !== 'string',\r\n            descriptors,\r\n            fontSource: typeof source === 'string'\r\n                ? source\r\n                : JSON.stringify(Array.from(new Uint8Array(source))),\r\n        });\r\n        return fontFace;\r\n    };\r\n    const restoreHandler = patch(doc.fonts, 'add', function (original) {\r\n        return function (fontFace) {\r\n            setTimeout(callbackWrapper(() => {\r\n                const p = fontMap.get(fontFace);\r\n                if (p) {\r\n                    fontCb(p);\r\n                    fontMap.delete(fontFace);\r\n                }\r\n            }), 0);\r\n            return original.apply(this, [fontFace]);\r\n        };\r\n    });\r\n    handlers.push(() => {\r\n        win.FontFace = originalFontFace;\r\n    });\r\n    handlers.push(restoreHandler);\r\n    return callbackWrapper(() => {\r\n        handlers.forEach((h) => h());\r\n    });\r\n}\r\nfunction initSelectionObserver(param) {\r\n    const { doc, mirror, blockClass, blockSelector, unblockSelector, selectionCb, } = param;\r\n    let collapsed = true;\r\n    const updateSelection = callbackWrapper(() => {\r\n        const selection = doc.getSelection();\r\n        if (!selection || (collapsed && selection?.isCollapsed))\r\n            return;\r\n        collapsed = selection.isCollapsed || false;\r\n        const ranges = [];\r\n        const count = selection.rangeCount || 0;\r\n        for (let i = 0; i < count; i++) {\r\n            const range = selection.getRangeAt(i);\r\n            const { startContainer, startOffset, endContainer, endOffset } = range;\r\n            const blocked = isBlocked(startContainer, blockClass, blockSelector, unblockSelector, true) ||\r\n                isBlocked(endContainer, blockClass, blockSelector, unblockSelector, true);\r\n            if (blocked)\r\n                continue;\r\n            ranges.push({\r\n                start: mirror.getId(startContainer),\r\n                startOffset,\r\n                end: mirror.getId(endContainer),\r\n                endOffset,\r\n            });\r\n        }\r\n        selectionCb({ ranges });\r\n    });\r\n    updateSelection();\r\n    return on('selectionchange', updateSelection);\r\n}\r\nfunction initCustomElementObserver({ doc, customElementCb, }) {\r\n    const win = doc.defaultView;\r\n    if (!win || !win.customElements)\r\n        return () => { };\r\n    const restoreHandler = patch(win.customElements, 'define', function (original) {\r\n        return function (name, constructor, options) {\r\n            try {\r\n                customElementCb({\r\n                    define: {\r\n                        name,\r\n                    },\r\n                });\r\n            }\r\n            catch (e) {\r\n            }\r\n            return original.apply(this, [name, constructor, options]);\r\n        };\r\n    });\r\n    return restoreHandler;\r\n}\r\nfunction initObservers(o, _hooks = {}) {\r\n    const currentWindow = o.doc.defaultView;\r\n    if (!currentWindow) {\r\n        return () => {\r\n        };\r\n    }\r\n    const mutationObserver = initMutationObserver(o, o.doc);\r\n    const mousemoveHandler = initMoveObserver(o);\r\n    const mouseInteractionHandler = initMouseInteractionObserver(o);\r\n    const scrollHandler = initScrollObserver(o);\r\n    const viewportResizeHandler = initViewportResizeObserver(o, {\r\n        win: currentWindow,\r\n    });\r\n    const inputHandler = initInputObserver(o);\r\n    const mediaInteractionHandler = initMediaInteractionObserver(o);\r\n    const styleSheetObserver = initStyleSheetObserver(o, { win: currentWindow });\r\n    const adoptedStyleSheetObserver = initAdoptedStyleSheetObserver(o, o.doc);\r\n    const styleDeclarationObserver = initStyleDeclarationObserver(o, {\r\n        win: currentWindow,\r\n    });\r\n    const fontObserver = o.collectFonts\r\n        ? initFontObserver(o)\r\n        : () => {\r\n        };\r\n    const selectionObserver = initSelectionObserver(o);\r\n    const customElementObserver = initCustomElementObserver(o);\r\n    const pluginHandlers = [];\r\n    for (const plugin of o.plugins) {\r\n        pluginHandlers.push(plugin.observer(plugin.callback, currentWindow, plugin.options));\r\n    }\r\n    return callbackWrapper(() => {\r\n        mutationBuffers.forEach((b) => b.reset());\r\n        mutationObserver.disconnect();\r\n        mousemoveHandler();\r\n        mouseInteractionHandler();\r\n        scrollHandler();\r\n        viewportResizeHandler();\r\n        inputHandler();\r\n        mediaInteractionHandler();\r\n        styleSheetObserver();\r\n        adoptedStyleSheetObserver();\r\n        styleDeclarationObserver();\r\n        fontObserver();\r\n        selectionObserver();\r\n        customElementObserver();\r\n        pluginHandlers.forEach((h) => h());\r\n    });\r\n}\r\nfunction hasNestedCSSRule(prop) {\r\n    return typeof window[prop] !== 'undefined';\r\n}\r\nfunction canMonkeyPatchNestedCSSRule(prop) {\r\n    return Boolean(typeof window[prop] !== 'undefined' &&\r\n        window[prop].prototype &&\r\n        'insertRule' in window[prop].prototype &&\r\n        'deleteRule' in window[prop].prototype);\r\n}\n\nexport { INPUT_TAGS, initAdoptedStyleSheetObserver, initMutationObserver, initObservers, initScrollObserver, mutationBuffers };\n","class CrossOriginIframeMirror {\r\n    constructor(generateIdFn) {\r\n        this.generateIdFn = generateIdFn;\r\n        this.iframeIdToRemoteIdMap = new WeakMap();\r\n        this.iframeRemoteIdToIdMap = new WeakMap();\r\n    }\r\n    getId(iframe, remoteId, idToRemoteMap, remoteToIdMap) {\r\n        const idToRemoteIdMap = idToRemoteMap || this.getIdToRemoteIdMap(iframe);\r\n        const remoteIdToIdMap = remoteToIdMap || this.getRemoteIdToIdMap(iframe);\r\n        let id = idToRemoteIdMap.get(remoteId);\r\n        if (!id) {\r\n            id = this.generateIdFn();\r\n            idToRemoteIdMap.set(remoteId, id);\r\n            remoteIdToIdMap.set(id, remoteId);\r\n        }\r\n        return id;\r\n    }\r\n    getIds(iframe, remoteId) {\r\n        const idToRemoteIdMap = this.getIdToRemoteIdMap(iframe);\r\n        const remoteIdToIdMap = this.getRemoteIdToIdMap(iframe);\r\n        return remoteId.map((id) => this.getId(iframe, id, idToRemoteIdMap, remoteIdToIdMap));\r\n    }\r\n    getRemoteId(iframe, id, map) {\r\n        const remoteIdToIdMap = map || this.getRemoteIdToIdMap(iframe);\r\n        if (typeof id !== 'number')\r\n            return id;\r\n        const remoteId = remoteIdToIdMap.get(id);\r\n        if (!remoteId)\r\n            return -1;\r\n        return remoteId;\r\n    }\r\n    getRemoteIds(iframe, ids) {\r\n        const remoteIdToIdMap = this.getRemoteIdToIdMap(iframe);\r\n        return ids.map((id) => this.getRemoteId(iframe, id, remoteIdToIdMap));\r\n    }\r\n    reset(iframe) {\r\n        if (!iframe) {\r\n            this.iframeIdToRemoteIdMap = new WeakMap();\r\n            this.iframeRemoteIdToIdMap = new WeakMap();\r\n            return;\r\n        }\r\n        this.iframeIdToRemoteIdMap.delete(iframe);\r\n        this.iframeRemoteIdToIdMap.delete(iframe);\r\n    }\r\n    getIdToRemoteIdMap(iframe) {\r\n        let idToRemoteIdMap = this.iframeIdToRemoteIdMap.get(iframe);\r\n        if (!idToRemoteIdMap) {\r\n            idToRemoteIdMap = new Map();\r\n            this.iframeIdToRemoteIdMap.set(iframe, idToRemoteIdMap);\r\n        }\r\n        return idToRemoteIdMap;\r\n    }\r\n    getRemoteIdToIdMap(iframe) {\r\n        let remoteIdToIdMap = this.iframeRemoteIdToIdMap.get(iframe);\r\n        if (!remoteIdToIdMap) {\r\n            remoteIdToIdMap = new Map();\r\n            this.iframeRemoteIdToIdMap.set(iframe, remoteIdToIdMap);\r\n        }\r\n        return remoteIdToIdMap;\r\n    }\r\n}\n\nexport { CrossOriginIframeMirror as default };\n","import { genId, NodeType } from '../../../rrweb-snapshot/es/rrweb-snapshot.js';\nimport CrossOriginIframeMirror from './cross-origin-iframe-mirror.js';\nimport { EventType, IncrementalSource } from '../../../types/dist/rrweb-types.js';\n\nclass IframeManagerNoop {\r\n    constructor() {\r\n        this.crossOriginIframeMirror = new CrossOriginIframeMirror(genId);\r\n        this.crossOriginIframeRootIdMap = new WeakMap();\r\n    }\r\n    addIframe() {\r\n    }\r\n    addLoadListener() {\r\n    }\r\n    attachIframe() {\r\n    }\r\n}\r\nclass IframeManager {\r\n    constructor(options) {\r\n        this.iframes = new WeakMap();\r\n        this.crossOriginIframeMap = new WeakMap();\r\n        this.crossOriginIframeMirror = new CrossOriginIframeMirror(genId);\r\n        this.crossOriginIframeRootIdMap = new WeakMap();\r\n        this.mutationCb = options.mutationCb;\r\n        this.wrappedEmit = options.wrappedEmit;\r\n        this.stylesheetManager = options.stylesheetManager;\r\n        this.recordCrossOriginIframes = options.recordCrossOriginIframes;\r\n        this.crossOriginIframeStyleMirror = new CrossOriginIframeMirror(this.stylesheetManager.styleMirror.generateId.bind(this.stylesheetManager.styleMirror));\r\n        this.mirror = options.mirror;\r\n        if (this.recordCrossOriginIframes) {\r\n            window.addEventListener('message', this.handleMessage.bind(this));\r\n        }\r\n    }\r\n    addIframe(iframeEl) {\r\n        this.iframes.set(iframeEl, true);\r\n        if (iframeEl.contentWindow)\r\n            this.crossOriginIframeMap.set(iframeEl.contentWindow, iframeEl);\r\n    }\r\n    addLoadListener(cb) {\r\n        this.loadListener = cb;\r\n    }\r\n    attachIframe(iframeEl, childSn) {\r\n        this.mutationCb({\r\n            adds: [\r\n                {\r\n                    parentId: this.mirror.getId(iframeEl),\r\n                    nextId: null,\r\n                    node: childSn,\r\n                },\r\n            ],\r\n            removes: [],\r\n            texts: [],\r\n            attributes: [],\r\n            isAttachIframe: true,\r\n        });\r\n        this.loadListener?.(iframeEl);\r\n        if (iframeEl.contentDocument &&\r\n            iframeEl.contentDocument.adoptedStyleSheets &&\r\n            iframeEl.contentDocument.adoptedStyleSheets.length > 0)\r\n            this.stylesheetManager.adoptStyleSheets(iframeEl.contentDocument.adoptedStyleSheets, this.mirror.getId(iframeEl.contentDocument));\r\n    }\r\n    handleMessage(message) {\r\n        const crossOriginMessageEvent = message;\r\n        if (crossOriginMessageEvent.data.type !== 'rrweb' ||\r\n            crossOriginMessageEvent.origin !== crossOriginMessageEvent.data.origin)\r\n            return;\r\n        const iframeSourceWindow = message.source;\r\n        if (!iframeSourceWindow)\r\n            return;\r\n        const iframeEl = this.crossOriginIframeMap.get(message.source);\r\n        if (!iframeEl)\r\n            return;\r\n        const transformedEvent = this.transformCrossOriginEvent(iframeEl, crossOriginMessageEvent.data.event);\r\n        if (transformedEvent)\r\n            this.wrappedEmit(transformedEvent, crossOriginMessageEvent.data.isCheckout);\r\n    }\r\n    transformCrossOriginEvent(iframeEl, e) {\r\n        switch (e.type) {\r\n            case EventType.FullSnapshot: {\r\n                this.crossOriginIframeMirror.reset(iframeEl);\r\n                this.crossOriginIframeStyleMirror.reset(iframeEl);\r\n                this.replaceIdOnNode(e.data.node, iframeEl);\r\n                const rootId = e.data.node.id;\r\n                this.crossOriginIframeRootIdMap.set(iframeEl, rootId);\r\n                this.patchRootIdOnNode(e.data.node, rootId);\r\n                return {\r\n                    timestamp: e.timestamp,\r\n                    type: EventType.IncrementalSnapshot,\r\n                    data: {\r\n                        source: IncrementalSource.Mutation,\r\n                        adds: [\r\n                            {\r\n                                parentId: this.mirror.getId(iframeEl),\r\n                                nextId: null,\r\n                                node: e.data.node,\r\n                            },\r\n                        ],\r\n                        removes: [],\r\n                        texts: [],\r\n                        attributes: [],\r\n                        isAttachIframe: true,\r\n                    },\r\n                };\r\n            }\r\n            case EventType.Meta:\r\n            case EventType.Load:\r\n            case EventType.DomContentLoaded: {\r\n                return false;\r\n            }\r\n            case EventType.Plugin: {\r\n                return e;\r\n            }\r\n            case EventType.Custom: {\r\n                this.replaceIds(e.data.payload, iframeEl, ['id', 'parentId', 'previousId', 'nextId']);\r\n                return e;\r\n            }\r\n            case EventType.IncrementalSnapshot: {\r\n                switch (e.data.source) {\r\n                    case IncrementalSource.Mutation: {\r\n                        e.data.adds.forEach((n) => {\r\n                            this.replaceIds(n, iframeEl, [\r\n                                'parentId',\r\n                                'nextId',\r\n                                'previousId',\r\n                            ]);\r\n                            this.replaceIdOnNode(n.node, iframeEl);\r\n                            const rootId = this.crossOriginIframeRootIdMap.get(iframeEl);\r\n                            rootId && this.patchRootIdOnNode(n.node, rootId);\r\n                        });\r\n                        e.data.removes.forEach((n) => {\r\n                            this.replaceIds(n, iframeEl, ['parentId', 'id']);\r\n                        });\r\n                        e.data.attributes.forEach((n) => {\r\n                            this.replaceIds(n, iframeEl, ['id']);\r\n                        });\r\n                        e.data.texts.forEach((n) => {\r\n                            this.replaceIds(n, iframeEl, ['id']);\r\n                        });\r\n                        return e;\r\n                    }\r\n                    case IncrementalSource.Drag:\r\n                    case IncrementalSource.TouchMove:\r\n                    case IncrementalSource.MouseMove: {\r\n                        e.data.positions.forEach((p) => {\r\n                            this.replaceIds(p, iframeEl, ['id']);\r\n                        });\r\n                        return e;\r\n                    }\r\n                    case IncrementalSource.ViewportResize: {\r\n                        return false;\r\n                    }\r\n                    case IncrementalSource.MediaInteraction:\r\n                    case IncrementalSource.MouseInteraction:\r\n                    case IncrementalSource.Scroll:\r\n                    case IncrementalSource.CanvasMutation:\r\n                    case IncrementalSource.Input: {\r\n                        this.replaceIds(e.data, iframeEl, ['id']);\r\n                        return e;\r\n                    }\r\n                    case IncrementalSource.StyleSheetRule:\r\n                    case IncrementalSource.StyleDeclaration: {\r\n                        this.replaceIds(e.data, iframeEl, ['id']);\r\n                        this.replaceStyleIds(e.data, iframeEl, ['styleId']);\r\n                        return e;\r\n                    }\r\n                    case IncrementalSource.Font: {\r\n                        return e;\r\n                    }\r\n                    case IncrementalSource.Selection: {\r\n                        e.data.ranges.forEach((range) => {\r\n                            this.replaceIds(range, iframeEl, ['start', 'end']);\r\n                        });\r\n                        return e;\r\n                    }\r\n                    case IncrementalSource.AdoptedStyleSheet: {\r\n                        this.replaceIds(e.data, iframeEl, ['id']);\r\n                        this.replaceStyleIds(e.data, iframeEl, ['styleIds']);\r\n                        e.data.styles?.forEach((style) => {\r\n                            this.replaceStyleIds(style, iframeEl, ['styleId']);\r\n                        });\r\n                        return e;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        return false;\r\n    }\r\n    replace(iframeMirror, obj, iframeEl, keys) {\r\n        for (const key of keys) {\r\n            if (!Array.isArray(obj[key]) && typeof obj[key] !== 'number')\r\n                continue;\r\n            if (Array.isArray(obj[key])) {\r\n                obj[key] = iframeMirror.getIds(iframeEl, obj[key]);\r\n            }\r\n            else {\r\n                obj[key] = iframeMirror.getId(iframeEl, obj[key]);\r\n            }\r\n        }\r\n        return obj;\r\n    }\r\n    replaceIds(obj, iframeEl, keys) {\r\n        return this.replace(this.crossOriginIframeMirror, obj, iframeEl, keys);\r\n    }\r\n    replaceStyleIds(obj, iframeEl, keys) {\r\n        return this.replace(this.crossOriginIframeStyleMirror, obj, iframeEl, keys);\r\n    }\r\n    replaceIdOnNode(node, iframeEl) {\r\n        this.replaceIds(node, iframeEl, ['id', 'rootId']);\r\n        if ('childNodes' in node) {\r\n            node.childNodes.forEach((child) => {\r\n                this.replaceIdOnNode(child, iframeEl);\r\n            });\r\n        }\r\n    }\r\n    patchRootIdOnNode(node, rootId) {\r\n        if (node.type !== NodeType.Document && !node.rootId)\r\n            node.rootId = rootId;\r\n        if ('childNodes' in node) {\r\n            node.childNodes.forEach((child) => {\r\n                this.patchRootIdOnNode(child, rootId);\r\n            });\r\n        }\r\n    }\r\n}\n\nexport { IframeManager, IframeManagerNoop };\n","import { createMirror, snapshot } from '../../../rrweb-snapshot/es/rrweb-snapshot.js';\nimport { initObservers, mutationBuffers } from './observer.js';\nimport { polyfill, on, nowTimestamp, getWindowWidth, getWindowHeight, getWindowScroll, isSerializedIframe, isSerializedStylesheet, hasShadowRoot } from '../utils.js';\nimport { EventType, IncrementalSource } from '../../../types/dist/rrweb-types.js';\nimport { IframeManagerNoop, IframeManager } from './iframe-manager.js';\nimport { ShadowDomManagerNoop, ShadowDomManager } from './shadow-dom-manager.js';\nimport { CanvasManagerNoop } from './observers/canvas/canvas-manager.js';\nexport { CanvasManager } from './observers/canvas/canvas-manager.js';\nimport { StylesheetManager } from './stylesheet-manager.js';\nimport ProcessedNodeManager from './processed-node-manager.js';\nimport { callbackWrapper, unregisterErrorHandler, registerErrorHandler } from './error-handler.js';\n\nlet wrappedEmit;\r\nlet _wrappedEmit;\r\nlet _takeFullSnapshot;\r\nconst mirror = createMirror();\r\nfunction record(options = {}) {\r\n    const { emit, checkoutEveryNms, checkoutEveryNth, blockClass = 'rr-block', blockSelector = null, unblockSelector = null, ignoreClass = 'rr-ignore', ignoreSelector = null, maskAllText = false, maskTextClass = 'rr-mask', unmaskTextClass = null, maskTextSelector = null, unmaskTextSelector = null, inlineStylesheet = true, maskAllInputs, maskInputOptions: _maskInputOptions, slimDOMOptions: _slimDOMOptions, maskAttributeFn, maskInputFn, maskTextFn, maxCanvasSize = null, packFn, sampling = {}, dataURLOptions = {}, mousemoveWait, recordCanvas = false, recordCrossOriginIframes = false, recordAfter = options.recordAfter === 'DOMContentLoaded'\r\n        ? options.recordAfter\r\n        : 'load', userTriggeredOnInput = false, collectFonts = false, inlineImages = false, plugins, keepIframeSrcFn = () => false, ignoreCSSAttributes = new Set([]), errorHandler, onMutation, getCanvasManager, } = options;\r\n    registerErrorHandler(errorHandler);\r\n    const inEmittingFrame = recordCrossOriginIframes\r\n        ? window.parent === window\r\n        : true;\r\n    let passEmitsToParent = false;\r\n    if (!inEmittingFrame) {\r\n        try {\r\n            if (window.parent.document) {\r\n                passEmitsToParent = false;\r\n            }\r\n        }\r\n        catch (e) {\r\n            passEmitsToParent = true;\r\n        }\r\n    }\r\n    if (inEmittingFrame && !emit) {\r\n        throw new Error('emit function is required');\r\n    }\r\n    if (mousemoveWait !== undefined && sampling.mousemove === undefined) {\r\n        sampling.mousemove = mousemoveWait;\r\n    }\r\n    mirror.reset();\r\n    const maskInputOptions = maskAllInputs === true\r\n        ? {\r\n            color: true,\r\n            date: true,\r\n            'datetime-local': true,\r\n            email: true,\r\n            month: true,\r\n            number: true,\r\n            range: true,\r\n            search: true,\r\n            tel: true,\r\n            text: true,\r\n            time: true,\r\n            url: true,\r\n            week: true,\r\n            textarea: true,\r\n            select: true,\r\n            radio: true,\r\n            checkbox: true,\r\n        }\r\n        : _maskInputOptions !== undefined\r\n            ? _maskInputOptions\r\n            : {};\r\n    const slimDOMOptions = _slimDOMOptions === true || _slimDOMOptions === 'all'\r\n        ? {\r\n            script: true,\r\n            comment: true,\r\n            headFavicon: true,\r\n            headWhitespace: true,\r\n            headMetaSocial: true,\r\n            headMetaRobots: true,\r\n            headMetaHttpEquiv: true,\r\n            headMetaVerification: true,\r\n            headMetaAuthorship: _slimDOMOptions === 'all',\r\n            headMetaDescKeywords: _slimDOMOptions === 'all',\r\n        }\r\n        : _slimDOMOptions\r\n            ? _slimDOMOptions\r\n            : {};\r\n    polyfill();\r\n    let lastFullSnapshotEvent;\r\n    let incrementalSnapshotCount = 0;\r\n    const eventProcessor = (e) => {\r\n        for (const plugin of plugins || []) {\r\n            if (plugin.eventProcessor) {\r\n                e = plugin.eventProcessor(e);\r\n            }\r\n        }\r\n        if (packFn &&\r\n            !passEmitsToParent) {\r\n            e = packFn(e);\r\n        }\r\n        return e;\r\n    };\r\n    wrappedEmit = (r, isCheckout) => {\r\n        const e = r;\r\n        e.timestamp = nowTimestamp();\r\n        if (mutationBuffers[0]?.isFrozen() &&\r\n            e.type !== EventType.FullSnapshot &&\r\n            !(e.type === EventType.IncrementalSnapshot &&\r\n                e.data.source === IncrementalSource.Mutation)) {\r\n            mutationBuffers.forEach((buf) => buf.unfreeze());\r\n        }\r\n        if (inEmittingFrame) {\r\n            emit?.(eventProcessor(e), isCheckout);\r\n        }\r\n        else if (passEmitsToParent) {\r\n            const message = {\r\n                type: 'rrweb',\r\n                event: eventProcessor(e),\r\n                origin: window.location.origin,\r\n                isCheckout,\r\n            };\r\n            window.parent.postMessage(message, '*');\r\n        }\r\n        if (e.type === EventType.FullSnapshot) {\r\n            lastFullSnapshotEvent = e;\r\n            incrementalSnapshotCount = 0;\r\n        }\r\n        else if (e.type === EventType.IncrementalSnapshot) {\r\n            if (e.data.source === IncrementalSource.Mutation &&\r\n                e.data.isAttachIframe) {\r\n                return;\r\n            }\r\n            incrementalSnapshotCount++;\r\n            const exceedCount = checkoutEveryNth && incrementalSnapshotCount >= checkoutEveryNth;\r\n            const exceedTime = checkoutEveryNms &&\r\n                lastFullSnapshotEvent &&\r\n                e.timestamp - lastFullSnapshotEvent.timestamp > checkoutEveryNms;\r\n            if (exceedCount || exceedTime) {\r\n                takeFullSnapshot(true);\r\n            }\r\n        }\r\n    };\r\n    _wrappedEmit = wrappedEmit;\r\n    const wrappedMutationEmit = (m) => {\r\n        wrappedEmit({\r\n            type: EventType.IncrementalSnapshot,\r\n            data: {\r\n                source: IncrementalSource.Mutation,\r\n                ...m,\r\n            },\r\n        });\r\n    };\r\n    const wrappedScrollEmit = (p) => wrappedEmit({\r\n        type: EventType.IncrementalSnapshot,\r\n        data: {\r\n            source: IncrementalSource.Scroll,\r\n            ...p,\r\n        },\r\n    });\r\n    const wrappedCanvasMutationEmit = (p) => wrappedEmit({\r\n        type: EventType.IncrementalSnapshot,\r\n        data: {\r\n            source: IncrementalSource.CanvasMutation,\r\n            ...p,\r\n        },\r\n    });\r\n    const wrappedAdoptedStyleSheetEmit = (a) => wrappedEmit({\r\n        type: EventType.IncrementalSnapshot,\r\n        data: {\r\n            source: IncrementalSource.AdoptedStyleSheet,\r\n            ...a,\r\n        },\r\n    });\r\n    const stylesheetManager = new StylesheetManager({\r\n        mutationCb: wrappedMutationEmit,\r\n        adoptedStyleSheetCb: wrappedAdoptedStyleSheetEmit,\r\n    });\r\n    const iframeManager = typeof __RRWEB_EXCLUDE_IFRAME__ === 'boolean' && __RRWEB_EXCLUDE_IFRAME__\r\n        ? new IframeManagerNoop()\r\n        : new IframeManager({\r\n            mirror,\r\n            mutationCb: wrappedMutationEmit,\r\n            stylesheetManager: stylesheetManager,\r\n            recordCrossOriginIframes,\r\n            wrappedEmit,\r\n        });\r\n    for (const plugin of plugins || []) {\r\n        if (plugin.getMirror)\r\n            plugin.getMirror({\r\n                nodeMirror: mirror,\r\n                crossOriginIframeMirror: iframeManager.crossOriginIframeMirror,\r\n                crossOriginIframeStyleMirror: iframeManager.crossOriginIframeStyleMirror,\r\n            });\r\n    }\r\n    const processedNodeManager = new ProcessedNodeManager();\r\n    const canvasManager = _getCanvasManager(getCanvasManager, {\r\n        mirror,\r\n        win: window,\r\n        mutationCb: (p) => wrappedEmit({\r\n            type: EventType.IncrementalSnapshot,\r\n            data: {\r\n                source: IncrementalSource.CanvasMutation,\r\n                ...p,\r\n            },\r\n        }),\r\n        recordCanvas,\r\n        blockClass,\r\n        blockSelector,\r\n        unblockSelector,\r\n        maxCanvasSize,\r\n        sampling: sampling['canvas'],\r\n        dataURLOptions,\r\n        errorHandler,\r\n    });\r\n    const shadowDomManager = typeof __RRWEB_EXCLUDE_SHADOW_DOM__ === 'boolean' &&\r\n        __RRWEB_EXCLUDE_SHADOW_DOM__\r\n        ? new ShadowDomManagerNoop()\r\n        : new ShadowDomManager({\r\n            mutationCb: wrappedMutationEmit,\r\n            scrollCb: wrappedScrollEmit,\r\n            bypassOptions: {\r\n                onMutation,\r\n                blockClass,\r\n                blockSelector,\r\n                unblockSelector,\r\n                maskAllText,\r\n                maskTextClass,\r\n                unmaskTextClass,\r\n                maskTextSelector,\r\n                unmaskTextSelector,\r\n                inlineStylesheet,\r\n                maskInputOptions,\r\n                dataURLOptions,\r\n                maskAttributeFn,\r\n                maskTextFn,\r\n                maskInputFn,\r\n                recordCanvas,\r\n                inlineImages,\r\n                sampling,\r\n                slimDOMOptions,\r\n                iframeManager,\r\n                stylesheetManager,\r\n                canvasManager,\r\n                keepIframeSrcFn,\r\n                processedNodeManager,\r\n            },\r\n            mirror,\r\n        });\r\n    const takeFullSnapshot = (isCheckout = false) => {\r\n        wrappedEmit({\r\n            type: EventType.Meta,\r\n            data: {\r\n                href: window.location.href,\r\n                width: getWindowWidth(),\r\n                height: getWindowHeight(),\r\n            },\r\n        }, isCheckout);\r\n        stylesheetManager.reset();\r\n        shadowDomManager.init();\r\n        mutationBuffers.forEach((buf) => buf.lock());\r\n        const node = snapshot(document, {\r\n            mirror,\r\n            blockClass,\r\n            blockSelector,\r\n            unblockSelector,\r\n            maskAllText,\r\n            maskTextClass,\r\n            unmaskTextClass,\r\n            maskTextSelector,\r\n            unmaskTextSelector,\r\n            inlineStylesheet,\r\n            maskAllInputs: maskInputOptions,\r\n            maskAttributeFn,\r\n            maskInputFn,\r\n            maskTextFn,\r\n            slimDOM: slimDOMOptions,\r\n            dataURLOptions,\r\n            recordCanvas,\r\n            inlineImages,\r\n            onSerialize: (n) => {\r\n                if (isSerializedIframe(n, mirror)) {\r\n                    iframeManager.addIframe(n);\r\n                }\r\n                if (isSerializedStylesheet(n, mirror)) {\r\n                    stylesheetManager.trackLinkElement(n);\r\n                }\r\n                if (hasShadowRoot(n)) {\r\n                    shadowDomManager.addShadowRoot(n.shadowRoot, document);\r\n                }\r\n            },\r\n            onIframeLoad: (iframe, childSn) => {\r\n                iframeManager.attachIframe(iframe, childSn);\r\n                shadowDomManager.observeAttachShadow(iframe);\r\n            },\r\n            onStylesheetLoad: (linkEl, childSn) => {\r\n                stylesheetManager.attachLinkElement(linkEl, childSn);\r\n            },\r\n            keepIframeSrcFn,\r\n        });\r\n        if (!node) {\r\n            return console.warn('Failed to snapshot the document');\r\n        }\r\n        wrappedEmit({\r\n            type: EventType.FullSnapshot,\r\n            data: {\r\n                node,\r\n                initialOffset: getWindowScroll(window),\r\n            },\r\n        });\r\n        mutationBuffers.forEach((buf) => buf.unlock());\r\n        if (document.adoptedStyleSheets && document.adoptedStyleSheets.length > 0)\r\n            stylesheetManager.adoptStyleSheets(document.adoptedStyleSheets, mirror.getId(document));\r\n    };\r\n    _takeFullSnapshot = takeFullSnapshot;\r\n    try {\r\n        const handlers = [];\r\n        const observe = (doc) => {\r\n            return callbackWrapper(initObservers)({\r\n                onMutation,\r\n                mutationCb: wrappedMutationEmit,\r\n                mousemoveCb: (positions, source) => wrappedEmit({\r\n                    type: EventType.IncrementalSnapshot,\r\n                    data: {\r\n                        source,\r\n                        positions,\r\n                    },\r\n                }),\r\n                mouseInteractionCb: (d) => wrappedEmit({\r\n                    type: EventType.IncrementalSnapshot,\r\n                    data: {\r\n                        source: IncrementalSource.MouseInteraction,\r\n                        ...d,\r\n                    },\r\n                }),\r\n                scrollCb: wrappedScrollEmit,\r\n                viewportResizeCb: (d) => wrappedEmit({\r\n                    type: EventType.IncrementalSnapshot,\r\n                    data: {\r\n                        source: IncrementalSource.ViewportResize,\r\n                        ...d,\r\n                    },\r\n                }),\r\n                inputCb: (v) => wrappedEmit({\r\n                    type: EventType.IncrementalSnapshot,\r\n                    data: {\r\n                        source: IncrementalSource.Input,\r\n                        ...v,\r\n                    },\r\n                }),\r\n                mediaInteractionCb: (p) => wrappedEmit({\r\n                    type: EventType.IncrementalSnapshot,\r\n                    data: {\r\n                        source: IncrementalSource.MediaInteraction,\r\n                        ...p,\r\n                    },\r\n                }),\r\n                styleSheetRuleCb: (r) => wrappedEmit({\r\n                    type: EventType.IncrementalSnapshot,\r\n                    data: {\r\n                        source: IncrementalSource.StyleSheetRule,\r\n                        ...r,\r\n                    },\r\n                }),\r\n                styleDeclarationCb: (r) => wrappedEmit({\r\n                    type: EventType.IncrementalSnapshot,\r\n                    data: {\r\n                        source: IncrementalSource.StyleDeclaration,\r\n                        ...r,\r\n                    },\r\n                }),\r\n                canvasMutationCb: wrappedCanvasMutationEmit,\r\n                fontCb: (p) => wrappedEmit({\r\n                    type: EventType.IncrementalSnapshot,\r\n                    data: {\r\n                        source: IncrementalSource.Font,\r\n                        ...p,\r\n                    },\r\n                }),\r\n                selectionCb: (p) => {\r\n                    wrappedEmit({\r\n                        type: EventType.IncrementalSnapshot,\r\n                        data: {\r\n                            source: IncrementalSource.Selection,\r\n                            ...p,\r\n                        },\r\n                    });\r\n                },\r\n                customElementCb: (c) => {\r\n                    wrappedEmit({\r\n                        type: EventType.IncrementalSnapshot,\r\n                        data: {\r\n                            source: IncrementalSource.CustomElement,\r\n                            ...c,\r\n                        },\r\n                    });\r\n                },\r\n                blockClass,\r\n                ignoreClass,\r\n                ignoreSelector,\r\n                maskAllText,\r\n                maskTextClass,\r\n                unmaskTextClass,\r\n                maskTextSelector,\r\n                unmaskTextSelector,\r\n                maskInputOptions,\r\n                inlineStylesheet,\r\n                sampling,\r\n                recordCanvas,\r\n                inlineImages,\r\n                userTriggeredOnInput,\r\n                collectFonts,\r\n                doc,\r\n                maskAttributeFn,\r\n                maskInputFn,\r\n                maskTextFn,\r\n                keepIframeSrcFn,\r\n                blockSelector,\r\n                unblockSelector,\r\n                slimDOMOptions,\r\n                dataURLOptions,\r\n                mirror,\r\n                iframeManager,\r\n                stylesheetManager,\r\n                shadowDomManager,\r\n                processedNodeManager,\r\n                canvasManager,\r\n                ignoreCSSAttributes,\r\n                plugins: plugins\r\n                    ?.filter((p) => p.observer)\r\n                    ?.map((p) => ({\r\n                    observer: p.observer,\r\n                    options: p.options,\r\n                    callback: (payload) => wrappedEmit({\r\n                        type: EventType.Plugin,\r\n                        data: {\r\n                            plugin: p.name,\r\n                            payload,\r\n                        },\r\n                    }),\r\n                })) || [],\r\n            }, {});\r\n        };\r\n        iframeManager.addLoadListener((iframeEl) => {\r\n            try {\r\n                handlers.push(observe(iframeEl.contentDocument));\r\n            }\r\n            catch (error) {\r\n                console.warn(error);\r\n            }\r\n        });\r\n        const init = () => {\r\n            takeFullSnapshot();\r\n            handlers.push(observe(document));\r\n        };\r\n        if (document.readyState === 'interactive' ||\r\n            document.readyState === 'complete') {\r\n            init();\r\n        }\r\n        else {\r\n            handlers.push(on('DOMContentLoaded', () => {\r\n                wrappedEmit({\r\n                    type: EventType.DomContentLoaded,\r\n                    data: {},\r\n                });\r\n                if (recordAfter === 'DOMContentLoaded')\r\n                    init();\r\n            }));\r\n            handlers.push(on('load', () => {\r\n                wrappedEmit({\r\n                    type: EventType.Load,\r\n                    data: {},\r\n                });\r\n                if (recordAfter === 'load')\r\n                    init();\r\n            }, window));\r\n        }\r\n        return () => {\r\n            handlers.forEach((h) => h());\r\n            processedNodeManager.destroy();\r\n            _takeFullSnapshot = undefined;\r\n            unregisterErrorHandler();\r\n        };\r\n    }\r\n    catch (error) {\r\n        console.warn(error);\r\n    }\r\n}\r\nfunction addCustomEvent(tag, payload) {\r\n    if (!_wrappedEmit) {\r\n        throw new Error('please add custom event after start recording');\r\n    }\r\n    wrappedEmit({\r\n        type: EventType.Custom,\r\n        data: {\r\n            tag,\r\n            payload,\r\n        },\r\n    });\r\n}\r\nfunction freezePage() {\r\n    mutationBuffers.forEach((buf) => buf.freeze());\r\n}\r\nfunction takeFullSnapshot(isCheckout) {\r\n    if (!_takeFullSnapshot) {\r\n        throw new Error('please take full snapshot after start recording');\r\n    }\r\n    _takeFullSnapshot(isCheckout);\r\n}\r\nrecord.mirror = mirror;\r\nrecord.takeFullSnapshot = takeFullSnapshot;\r\nfunction _getCanvasManager(getCanvasManagerFn, options) {\r\n    try {\r\n        return getCanvasManagerFn\r\n            ? getCanvasManagerFn(options)\r\n            : new CanvasManagerNoop();\r\n    }\r\n    catch {\r\n        console.warn('Unable to initialize CanvasManager');\r\n        return new CanvasManagerNoop();\r\n    }\r\n}\n\nexport { addCustomEvent, record as default, freezePage, mirror, takeFullSnapshot };\n","import { initMutationObserver, initScrollObserver, initAdoptedStyleSheetObserver } from './observer.js';\nimport { setTimeout, patch, inDom } from '../utils.js';\nimport { isNativeShadowDom } from '../../../rrweb-snapshot/es/rrweb-snapshot.js';\n\nclass ShadowDomManagerNoop {\r\n    init() {\r\n    }\r\n    addShadowRoot() {\r\n    }\r\n    observeAttachShadow() {\r\n    }\r\n    reset() {\r\n    }\r\n}\r\nclass ShadowDomManager {\r\n    constructor(options) {\r\n        this.shadowDoms = new WeakSet();\r\n        this.restoreHandlers = [];\r\n        this.mutationCb = options.mutationCb;\r\n        this.scrollCb = options.scrollCb;\r\n        this.bypassOptions = options.bypassOptions;\r\n        this.mirror = options.mirror;\r\n        this.init();\r\n    }\r\n    init() {\r\n        this.reset();\r\n        this.patchAttachShadow(Element, document);\r\n    }\r\n    addShadowRoot(shadowRoot, doc) {\r\n        if (!isNativeShadowDom(shadowRoot))\r\n            return;\r\n        if (this.shadowDoms.has(shadowRoot))\r\n            return;\r\n        this.shadowDoms.add(shadowRoot);\r\n        const observer = initMutationObserver({\r\n            ...this.bypassOptions,\r\n            doc,\r\n            mutationCb: this.mutationCb,\r\n            mirror: this.mirror,\r\n            shadowDomManager: this,\r\n        }, shadowRoot);\r\n        this.restoreHandlers.push(() => observer.disconnect());\r\n        this.restoreHandlers.push(initScrollObserver({\r\n            ...this.bypassOptions,\r\n            scrollCb: this.scrollCb,\r\n            doc: shadowRoot,\r\n            mirror: this.mirror,\r\n        }));\r\n        setTimeout(() => {\r\n            if (shadowRoot.adoptedStyleSheets &&\r\n                shadowRoot.adoptedStyleSheets.length > 0)\r\n                this.bypassOptions.stylesheetManager.adoptStyleSheets(shadowRoot.adoptedStyleSheets, this.mirror.getId(shadowRoot.host));\r\n            this.restoreHandlers.push(initAdoptedStyleSheetObserver({\r\n                mirror: this.mirror,\r\n                stylesheetManager: this.bypassOptions.stylesheetManager,\r\n            }, shadowRoot));\r\n        }, 0);\r\n    }\r\n    observeAttachShadow(iframeElement) {\r\n        if (!iframeElement.contentWindow || !iframeElement.contentDocument)\r\n            return;\r\n        this.patchAttachShadow(iframeElement.contentWindow.Element, iframeElement.contentDocument);\r\n    }\r\n    patchAttachShadow(element, doc) {\r\n        const manager = this;\r\n        this.restoreHandlers.push(patch(element.prototype, 'attachShadow', function (original) {\r\n            return function (option) {\r\n                const shadowRoot = original.call(this, option);\r\n                if (this.shadowRoot && inDom(this))\r\n                    manager.addShadowRoot(this.shadowRoot, doc);\r\n                return shadowRoot;\r\n            };\r\n        }));\r\n    }\r\n    reset() {\r\n        this.restoreHandlers.forEach((handler) => {\r\n            try {\r\n                handler();\r\n            }\r\n            catch (e) {\r\n            }\r\n        });\r\n        this.restoreHandlers = [];\r\n        this.shadowDoms = new WeakSet();\r\n    }\r\n}\n\nexport { ShadowDomManager, ShadowDomManagerNoop };\n","import { onRequestAnimationFrame, isBlocked } from '../../../utils.js';\nimport { CanvasContext } from '../../../../../types/dist/rrweb-types.js';\nimport initCanvas2DMutationObserver from './2d.js';\nimport initCanvasContextObserver from './canvas.js';\nimport initCanvasWebGLMutationObserver from './webgl.js';\nimport { getImageBitmapDataUrlWorkerURL as t } from '../../../../../rrweb-worker/es/rrweb-worker/index.js';\nimport { callbackWrapper, registerErrorHandler } from '../../error-handler.js';\n\nclass CanvasManagerNoop {\r\n    reset() {\r\n    }\r\n    freeze() {\r\n    }\r\n    unfreeze() {\r\n    }\r\n    lock() {\r\n    }\r\n    unlock() {\r\n    }\r\n    snapshot() {\r\n    }\r\n}\r\nclass CanvasManager {\r\n    reset() {\r\n        this.pendingCanvasMutations.clear();\r\n        this.resetObservers && this.resetObservers();\r\n    }\r\n    freeze() {\r\n        this.frozen = true;\r\n    }\r\n    unfreeze() {\r\n        this.frozen = false;\r\n    }\r\n    lock() {\r\n        this.locked = true;\r\n    }\r\n    unlock() {\r\n        this.locked = false;\r\n    }\r\n    constructor(options) {\r\n        this.pendingCanvasMutations = new Map();\r\n        this.rafStamps = { latestId: 0, invokeId: null };\r\n        this.frozen = false;\r\n        this.locked = false;\r\n        this.processMutation = (target, mutation) => {\r\n            const newFrame = this.rafStamps.invokeId &&\r\n                this.rafStamps.latestId !== this.rafStamps.invokeId;\r\n            if (newFrame || !this.rafStamps.invokeId)\r\n                this.rafStamps.invokeId = this.rafStamps.latestId;\r\n            if (!this.pendingCanvasMutations.has(target)) {\r\n                this.pendingCanvasMutations.set(target, []);\r\n            }\r\n            this.pendingCanvasMutations.get(target).push(mutation);\r\n        };\r\n        const { sampling = 'all', win, blockClass, blockSelector, unblockSelector, maxCanvasSize, recordCanvas, dataURLOptions, errorHandler, } = options;\r\n        this.mutationCb = options.mutationCb;\r\n        this.mirror = options.mirror;\r\n        this.options = options;\r\n        if (errorHandler) {\r\n            registerErrorHandler(errorHandler);\r\n        }\r\n        if (options.enableManualSnapshot) {\r\n            return;\r\n        }\r\n        callbackWrapper(() => {\r\n            if (recordCanvas && sampling === 'all')\r\n                this.initCanvasMutationObserver(win, blockClass, blockSelector, unblockSelector);\r\n            if (recordCanvas && typeof sampling === 'number')\r\n                this.initCanvasFPSObserver(sampling, win, blockClass, blockSelector, unblockSelector, maxCanvasSize, {\r\n                    dataURLOptions,\r\n                });\r\n        })();\r\n    }\r\n    initCanvasFPSObserver(fps, win, blockClass, blockSelector, unblockSelector, maxCanvasSize, options) {\r\n        const canvasContextReset = initCanvasContextObserver(win, blockClass, blockSelector, unblockSelector, true);\r\n        const rafId = this.takeSnapshot(false, fps, win, blockClass, blockSelector, unblockSelector, maxCanvasSize, options.dataURLOptions);\r\n        this.resetObservers = () => {\r\n            canvasContextReset();\r\n            cancelAnimationFrame(rafId);\r\n        };\r\n    }\r\n    initCanvasMutationObserver(win, blockClass, blockSelector, unblockSelector) {\r\n        this.startRAFTimestamping();\r\n        this.startPendingCanvasMutationFlusher();\r\n        const canvasContextReset = initCanvasContextObserver(win, blockClass, blockSelector, unblockSelector, false);\r\n        const canvas2DReset = initCanvas2DMutationObserver(this.processMutation.bind(this), win, blockClass, blockSelector, unblockSelector);\r\n        const canvasWebGL1and2Reset = initCanvasWebGLMutationObserver(this.processMutation.bind(this), win, blockClass, blockSelector, unblockSelector, this.mirror);\r\n        this.resetObservers = () => {\r\n            canvasContextReset();\r\n            canvas2DReset();\r\n            canvasWebGL1and2Reset();\r\n        };\r\n    }\r\n    snapshot(canvasElement) {\r\n        const { options } = this;\r\n        const rafId = this.takeSnapshot(true, options.sampling === 'all' ? 2 : options.sampling || 2, options.win, options.blockClass, options.blockSelector, options.unblockSelector, options.maxCanvasSize, options.dataURLOptions, canvasElement);\r\n        this.resetObservers = () => {\r\n            cancelAnimationFrame(rafId);\r\n        };\r\n    }\r\n    takeSnapshot(isManualSnapshot, fps, win, blockClass, blockSelector, unblockSelector, maxCanvasSize, dataURLOptions, canvasElement) {\r\n        const snapshotInProgressMap = new Map();\r\n        const worker = new Worker(t());\r\n        worker.onmessage = (e) => {\r\n            const data = e.data;\r\n            const { id } = data;\r\n            snapshotInProgressMap.set(id, false);\r\n            if (!('base64' in data))\r\n                return;\r\n            const { base64, type, width, height } = data;\r\n            this.mutationCb({\r\n                id,\r\n                type: CanvasContext['2D'],\r\n                commands: [\r\n                    {\r\n                        property: 'clearRect',\r\n                        args: [0, 0, width, height],\r\n                    },\r\n                    {\r\n                        property: 'drawImage',\r\n                        args: [\r\n                            {\r\n                                rr_type: 'ImageBitmap',\r\n                                args: [\r\n                                    {\r\n                                        rr_type: 'Blob',\r\n                                        data: [{ rr_type: 'ArrayBuffer', base64 }],\r\n                                        type,\r\n                                    },\r\n                                ],\r\n                            },\r\n                            0,\r\n                            0,\r\n                            width,\r\n                            height,\r\n                        ],\r\n                    },\r\n                ],\r\n            });\r\n        };\r\n        const timeBetweenSnapshots = 1000 / fps;\r\n        let lastSnapshotTime = 0;\r\n        let rafId;\r\n        const getCanvas = (canvasElement) => {\r\n            if (canvasElement) {\r\n                return [canvasElement];\r\n            }\r\n            const matchedCanvas = [];\r\n            win.document.querySelectorAll('canvas').forEach((canvas) => {\r\n                if (!isBlocked(canvas, blockClass, blockSelector, unblockSelector, true)) {\r\n                    matchedCanvas.push(canvas);\r\n                }\r\n            });\r\n            return matchedCanvas;\r\n        };\r\n        const takeCanvasSnapshots = (timestamp) => {\r\n            if (lastSnapshotTime &&\r\n                timestamp - lastSnapshotTime < timeBetweenSnapshots) {\r\n                rafId = onRequestAnimationFrame(takeCanvasSnapshots);\r\n                return;\r\n            }\r\n            lastSnapshotTime = timestamp;\r\n            getCanvas(canvasElement).forEach((canvas) => {\r\n                const id = this.mirror.getId(canvas);\r\n                if (snapshotInProgressMap.get(id))\r\n                    return;\r\n                if (!canvas.width || !canvas.height)\r\n                    return;\r\n                snapshotInProgressMap.set(id, true);\r\n                if (!isManualSnapshot &&\r\n                    ['webgl', 'webgl2'].includes(canvas.__context)) {\r\n                    const context = canvas.getContext(canvas.__context);\r\n                    if (context?.getContextAttributes()?.preserveDrawingBuffer === false) {\r\n                        context.clear(context.COLOR_BUFFER_BIT);\r\n                    }\r\n                }\r\n                createImageBitmap(canvas)\r\n                    .then((bitmap) => {\r\n                    worker.postMessage({\r\n                        id,\r\n                        bitmap,\r\n                        width: canvas.width,\r\n                        height: canvas.height,\r\n                        dataURLOptions,\r\n                        maxCanvasSize,\r\n                    }, [bitmap]);\r\n                })\r\n                    .catch((error) => {\r\n                    callbackWrapper(() => {\r\n                        throw error;\r\n                    })();\r\n                });\r\n            });\r\n            rafId = onRequestAnimationFrame(takeCanvasSnapshots);\r\n        };\r\n        rafId = onRequestAnimationFrame(takeCanvasSnapshots);\r\n        return rafId;\r\n    }\r\n    startPendingCanvasMutationFlusher() {\r\n        onRequestAnimationFrame(() => this.flushPendingCanvasMutations());\r\n    }\r\n    startRAFTimestamping() {\r\n        const setLatestRAFTimestamp = (timestamp) => {\r\n            this.rafStamps.latestId = timestamp;\r\n            onRequestAnimationFrame(setLatestRAFTimestamp);\r\n        };\r\n        onRequestAnimationFrame(setLatestRAFTimestamp);\r\n    }\r\n    flushPendingCanvasMutations() {\r\n        this.pendingCanvasMutations.forEach((values, canvas) => {\r\n            const id = this.mirror.getId(canvas);\r\n            this.flushPendingCanvasMutationFor(canvas, id);\r\n        });\r\n        onRequestAnimationFrame(() => this.flushPendingCanvasMutations());\r\n    }\r\n    flushPendingCanvasMutationFor(canvas, id) {\r\n        if (this.frozen || this.locked) {\r\n            return;\r\n        }\r\n        const valuesWithType = this.pendingCanvasMutations.get(canvas);\r\n        if (!valuesWithType || id === -1)\r\n            return;\r\n        const values = valuesWithType.map((value) => {\r\n            const { type, ...rest } = value;\r\n            return rest;\r\n        });\r\n        const { type } = valuesWithType[0];\r\n        this.mutationCb({ id, type, commands: values });\r\n        this.pendingCanvasMutations.delete(canvas);\r\n    }\r\n}\n\nexport { CanvasManager, CanvasManagerNoop };\n","import { stringifyRule } from '../../../rrweb-snapshot/es/rrweb-snapshot.js';\nimport { StyleSheetMirror } from '../utils.js';\n\nclass StylesheetManager {\r\n    constructor(options) {\r\n        this.trackedLinkElements = new WeakSet();\r\n        this.styleMirror = new StyleSheetMirror();\r\n        this.mutationCb = options.mutationCb;\r\n        this.adoptedStyleSheetCb = options.adoptedStyleSheetCb;\r\n    }\r\n    attachLinkElement(linkEl, childSn) {\r\n        if ('_cssText' in childSn.attributes)\r\n            this.mutationCb({\r\n                adds: [],\r\n                removes: [],\r\n                texts: [],\r\n                attributes: [\r\n                    {\r\n                        id: childSn.id,\r\n                        attributes: childSn\r\n                            .attributes,\r\n                    },\r\n                ],\r\n            });\r\n        this.trackLinkElement(linkEl);\r\n    }\r\n    trackLinkElement(linkEl) {\r\n        if (this.trackedLinkElements.has(linkEl))\r\n            return;\r\n        this.trackedLinkElements.add(linkEl);\r\n        this.trackStylesheetInLinkElement(linkEl);\r\n    }\r\n    adoptStyleSheets(sheets, hostId) {\r\n        if (sheets.length === 0)\r\n            return;\r\n        const adoptedStyleSheetData = {\r\n            id: hostId,\r\n            styleIds: [],\r\n        };\r\n        const styles = [];\r\n        for (const sheet of sheets) {\r\n            let styleId;\r\n            if (!this.styleMirror.has(sheet)) {\r\n                styleId = this.styleMirror.add(sheet);\r\n                styles.push({\r\n                    styleId,\r\n                    rules: Array.from(sheet.rules || CSSRule, (r, index) => ({\r\n                        rule: stringifyRule(r),\r\n                        index,\r\n                    })),\r\n                });\r\n            }\r\n            else\r\n                styleId = this.styleMirror.getId(sheet);\r\n            adoptedStyleSheetData.styleIds.push(styleId);\r\n        }\r\n        if (styles.length > 0)\r\n            adoptedStyleSheetData.styles = styles;\r\n        this.adoptedStyleSheetCb(adoptedStyleSheetData);\r\n    }\r\n    reset() {\r\n        this.styleMirror.reset();\r\n        this.trackedLinkElements = new WeakSet();\r\n    }\r\n    trackStylesheetInLinkElement(linkEl) {\r\n    }\r\n}\n\nexport { StylesheetManager };\n","import { onRequestAnimationFrame } from '../utils.js';\n\nclass ProcessedNodeManager {\r\n    constructor() {\r\n        this.nodeMap = new WeakMap();\r\n        this.loop = true;\r\n        this.periodicallyClear();\r\n    }\r\n    periodicallyClear() {\r\n        onRequestAnimationFrame(() => {\r\n            this.clear();\r\n            if (this.loop)\r\n                this.periodicallyClear();\r\n        });\r\n    }\r\n    inOtherBuffer(node, thisBuffer) {\r\n        const buffers = this.nodeMap.get(node);\r\n        return (buffers && Array.from(buffers).some((buffer) => buffer !== thisBuffer));\r\n    }\r\n    add(node, buffer) {\r\n        this.nodeMap.set(node, (this.nodeMap.get(node) || new Set()).add(buffer));\r\n    }\r\n    clear() {\r\n        this.nodeMap = new WeakMap();\r\n    }\r\n    destroy() {\r\n        this.loop = false;\r\n    }\r\n}\n\nexport { ProcessedNodeManager as default };\n","/**\n * Converts a timestamp to ms, if it was in s, or keeps it as ms.\n */\nexport function timestampToMs(timestamp: number): number {\n  const isMs = timestamp > 9999999999;\n  return isMs ? timestamp : timestamp * 1000;\n}\n\n/**\n * Converts a timestamp to s, if it was in ms, or keeps it as s.\n */\nexport function timestampToS(timestamp: number): number {\n  const isMs = timestamp > 9999999999;\n  return isMs ? timestamp / 1000 : timestamp;\n}\n","import { EventType } from '@sentry-internal/rrweb';\nimport type { Breadcrumb } from '@sentry/types';\nimport { normalize } from '@sentry/utils';\n\nimport type { ReplayContainer } from '../../types';\n\n/**\n * Add a breadcrumb event to replay.\n */\nexport function addBreadcrumbEvent(replay: ReplayContainer, breadcrumb: Breadcrumb): void {\n  if (breadcrumb.category === 'sentry.transaction') {\n    return;\n  }\n\n  if (['ui.click', 'ui.input'].includes(breadcrumb.category as string)) {\n    replay.triggerUserActivity();\n  } else {\n    replay.checkAndHandleExpiredSession();\n  }\n\n  replay.addUpdate(() => {\n    // This should never reject\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    replay.throttledAddEvent({\n      type: EventType.Custom,\n      // TODO: We were converting from ms to seconds for breadcrumbs, spans,\n      // but maybe we should just keep them as milliseconds\n      timestamp: (breadcrumb.timestamp || 0) * 1000,\n      data: {\n        tag: 'breadcrumb',\n        // normalize to max. 10 depth and 1_000 properties per object\n        payload: normalize(breadcrumb, 10, 1_000),\n      },\n    });\n\n    // Do not flush after console log messages\n    return breadcrumb.category === 'console';\n  });\n}\n","import type { INode } from '@sentry-internal/rrweb-snapshot';\n\nconst INTERACTIVE_SELECTOR = 'button,a';\n\n/** Get the closest interactive parent element, or else return the given element. */\nexport function getClosestInteractive(element: Element): Element {\n  const closestInteractive = element.closest(INTERACTIVE_SELECTOR);\n  return closestInteractive || element;\n}\n\n/**\n * For clicks, we check if the target is inside of a button or link\n * If so, we use this as the target instead\n * This is useful because if you click on the image in <button><img></button>,\n * The target will be the image, not the button, which we don't want here\n */\nexport function getClickTargetNode(event: Event | MouseEvent | Node): Node | INode | null {\n  const target = getTargetNode(event);\n\n  if (!target || !(target instanceof Element)) {\n    return target;\n  }\n\n  return getClosestInteractive(target);\n}\n\n/** Get the event target node. */\nexport function getTargetNode(event: Node | { target: EventTarget | null }): Node | INode | null {\n  if (isEventWithTarget(event)) {\n    return event.target as Node | null;\n  }\n\n  return event;\n}\n\nfunction isEventWithTarget(event: unknown): event is { target: EventTarget | null } {\n  return typeof event === 'object' && !!event && 'target' in event;\n}\n","import { fill } from '@sentry/utils';\n\nimport { WINDOW } from '../../constants';\n\ntype WindowOpenHandler = () => void;\n\nlet handlers: undefined | WindowOpenHandler[];\n\n/**\n * Register a handler to be called when `window.open()` is called.\n * Returns a cleanup function.\n */\nexport function onWindowOpen(cb: WindowOpenHandler): () => void {\n  // Ensure to only register this once\n  if (!handlers) {\n    handlers = [];\n    monkeyPatchWindowOpen();\n  }\n\n  handlers.push(cb);\n\n  return () => {\n    const pos = handlers ? handlers.indexOf(cb) : -1;\n    if (pos > -1) {\n      (handlers as WindowOpenHandler[]).splice(pos, 1);\n    }\n  };\n}\n\nfunction monkeyPatchWindowOpen(): void {\n  fill(WINDOW, 'open', function (originalWindowOpen: () => void): () => void {\n    return function (...args: unknown[]): void {\n      if (handlers) {\n        try {\n          handlers.forEach(handler => handler());\n        } catch (e) {\n          // ignore errors in here\n        }\n      }\n\n      return originalWindowOpen.apply(WINDOW, args);\n    };\n  });\n}\n","import { IncrementalSource, MouseInteractions, record } from '@sentry-internal/rrweb';\nimport type { Breadcrumb } from '@sentry/types';\n\nimport { WINDOW } from '../constants';\nimport type {\n  RecordingEvent,\n  ReplayClickDetector,\n  ReplayContainer,\n  ReplayMultiClickFrame,\n  ReplaySlowClickFrame,\n  SlowClickConfig,\n} from '../types';\nimport { ReplayEventTypeIncrementalSnapshot } from '../types';\nimport { timestampToS } from '../util/timestamp';\nimport { addBreadcrumbEvent } from './util/addBreadcrumbEvent';\nimport { getClosestInteractive } from './util/domUtils';\nimport { onWindowOpen } from './util/onWindowOpen';\n\ntype ClickBreadcrumb = Breadcrumb & {\n  timestamp: number;\n};\n\ninterface Click {\n  timestamp: number;\n  mutationAfter?: number;\n  scrollAfter?: number;\n  clickBreadcrumb: ClickBreadcrumb;\n  clickCount: number;\n  node: HTMLElement;\n}\n\ntype IncrementalRecordingEvent = RecordingEvent & {\n  type: typeof ReplayEventTypeIncrementalSnapshot;\n  data: { source: IncrementalSource };\n};\n\ntype IncrementalMouseInteractionRecordingEvent = IncrementalRecordingEvent & {\n  type: typeof ReplayEventTypeIncrementalSnapshot;\n  data: { type: MouseInteractions; id: number };\n};\n\n/** Handle a click. */\nexport function handleClick(clickDetector: ReplayClickDetector, clickBreadcrumb: Breadcrumb, node: HTMLElement): void {\n  clickDetector.handleClick(clickBreadcrumb, node);\n}\n\n/** A click detector class that can be used to detect slow or rage clicks on elements. */\nexport class ClickDetector implements ReplayClickDetector {\n  // protected for testing\n  protected _lastMutation: number;\n  protected _lastScroll: number;\n\n  private _clicks: Click[];\n  private _teardown: undefined | (() => void);\n\n  private _threshold: number;\n  private _scollTimeout: number;\n  private _timeout: number;\n  private _ignoreSelector: string;\n\n  private _replay: ReplayContainer;\n  private _checkClickTimeout?: ReturnType<typeof setTimeout>;\n  private _addBreadcrumbEvent: typeof addBreadcrumbEvent;\n\n  public constructor(\n    replay: ReplayContainer,\n    slowClickConfig: SlowClickConfig,\n    // Just for easier testing\n    _addBreadcrumbEvent = addBreadcrumbEvent,\n  ) {\n    this._lastMutation = 0;\n    this._lastScroll = 0;\n    this._clicks = [];\n\n    // We want everything in s, but options are in ms\n    this._timeout = slowClickConfig.timeout / 1000;\n    this._threshold = slowClickConfig.threshold / 1000;\n    this._scollTimeout = slowClickConfig.scrollTimeout / 1000;\n    this._replay = replay;\n    this._ignoreSelector = slowClickConfig.ignoreSelector;\n    this._addBreadcrumbEvent = _addBreadcrumbEvent;\n  }\n\n  /** Register click detection handlers on mutation or scroll. */\n  public addListeners(): void {\n    const cleanupWindowOpen = onWindowOpen(() => {\n      // Treat window.open as mutation\n      this._lastMutation = nowInSeconds();\n    });\n\n    this._teardown = () => {\n      cleanupWindowOpen();\n\n      this._clicks = [];\n      this._lastMutation = 0;\n      this._lastScroll = 0;\n    };\n  }\n\n  /** Clean up listeners. */\n  public removeListeners(): void {\n    if (this._teardown) {\n      this._teardown();\n    }\n\n    if (this._checkClickTimeout) {\n      clearTimeout(this._checkClickTimeout);\n    }\n  }\n\n  /** @inheritDoc */\n  public handleClick(breadcrumb: Breadcrumb, node: HTMLElement): void {\n    if (ignoreElement(node, this._ignoreSelector) || !isClickBreadcrumb(breadcrumb)) {\n      return;\n    }\n\n    const newClick: Click = {\n      timestamp: timestampToS(breadcrumb.timestamp),\n      clickBreadcrumb: breadcrumb,\n      // Set this to 0 so we know it originates from the click breadcrumb\n      clickCount: 0,\n      node,\n    };\n\n    // If there was a click in the last 1s on the same element, ignore it - only keep a single reference per second\n    if (\n      this._clicks.some(click => click.node === newClick.node && Math.abs(click.timestamp - newClick.timestamp) < 1)\n    ) {\n      return;\n    }\n\n    this._clicks.push(newClick);\n\n    // If this is the first new click, set a timeout to check for multi clicks\n    if (this._clicks.length === 1) {\n      this._scheduleCheckClicks();\n    }\n  }\n\n  /** @inheritDoc */\n  public registerMutation(timestamp = Date.now()): void {\n    this._lastMutation = timestampToS(timestamp);\n  }\n\n  /** @inheritDoc */\n  public registerScroll(timestamp = Date.now()): void {\n    this._lastScroll = timestampToS(timestamp);\n  }\n\n  /** @inheritDoc */\n  public registerClick(element: HTMLElement): void {\n    const node = getClosestInteractive(element);\n    this._handleMultiClick(node as HTMLElement);\n  }\n\n  /** Count multiple clicks on elements. */\n  private _handleMultiClick(node: HTMLElement): void {\n    this._getClicks(node).forEach(click => {\n      click.clickCount++;\n    });\n  }\n\n  /** Get all pending clicks for a given node. */\n  private _getClicks(node: HTMLElement): Click[] {\n    return this._clicks.filter(click => click.node === node);\n  }\n\n  /** Check the clicks that happened. */\n  private _checkClicks(): void {\n    const timedOutClicks: Click[] = [];\n\n    const now = nowInSeconds();\n\n    this._clicks.forEach(click => {\n      if (!click.mutationAfter && this._lastMutation) {\n        click.mutationAfter = click.timestamp <= this._lastMutation ? this._lastMutation - click.timestamp : undefined;\n      }\n      if (!click.scrollAfter && this._lastScroll) {\n        click.scrollAfter = click.timestamp <= this._lastScroll ? this._lastScroll - click.timestamp : undefined;\n      }\n\n      // All of these are in seconds!\n      if (click.timestamp + this._timeout <= now) {\n        timedOutClicks.push(click);\n      }\n    });\n\n    // Remove \"old\" clicks\n    for (const click of timedOutClicks) {\n      const pos = this._clicks.indexOf(click);\n\n      if (pos > -1) {\n        this._generateBreadcrumbs(click);\n        this._clicks.splice(pos, 1);\n      }\n    }\n\n    // Trigger new check, unless no clicks left\n    if (this._clicks.length) {\n      this._scheduleCheckClicks();\n    }\n  }\n\n  /** Generate matching breadcrumb(s) for the click. */\n  private _generateBreadcrumbs(click: Click): void {\n    const replay = this._replay;\n    const hadScroll = click.scrollAfter && click.scrollAfter <= this._scollTimeout;\n    const hadMutation = click.mutationAfter && click.mutationAfter <= this._threshold;\n\n    const isSlowClick = !hadScroll && !hadMutation;\n    const { clickCount, clickBreadcrumb } = click;\n\n    // Slow click\n    if (isSlowClick) {\n      // If `mutationAfter` is set, it means a mutation happened after the threshold, but before the timeout\n      // If not, it means we just timed out without scroll & mutation\n      const timeAfterClickMs = Math.min(click.mutationAfter || this._timeout, this._timeout) * 1000;\n      const endReason = timeAfterClickMs < this._timeout * 1000 ? 'mutation' : 'timeout';\n\n      const breadcrumb: ReplaySlowClickFrame = {\n        type: 'default',\n        message: clickBreadcrumb.message,\n        timestamp: clickBreadcrumb.timestamp,\n        category: 'ui.slowClickDetected',\n        data: {\n          ...clickBreadcrumb.data,\n          url: WINDOW.location.href,\n          route: replay.getCurrentRoute(),\n          timeAfterClickMs,\n          endReason,\n          // If clickCount === 0, it means multiClick was not correctly captured here\n          // - we still want to send 1 in this case\n          clickCount: clickCount || 1,\n        },\n      };\n\n      this._addBreadcrumbEvent(replay, breadcrumb);\n      return;\n    }\n\n    // Multi click\n    if (clickCount > 1) {\n      const breadcrumb: ReplayMultiClickFrame = {\n        type: 'default',\n        message: clickBreadcrumb.message,\n        timestamp: clickBreadcrumb.timestamp,\n        category: 'ui.multiClick',\n        data: {\n          ...clickBreadcrumb.data,\n          url: WINDOW.location.href,\n          route: replay.getCurrentRoute(),\n          clickCount,\n          metric: true,\n        },\n      };\n\n      this._addBreadcrumbEvent(replay, breadcrumb);\n    }\n  }\n\n  /** Schedule to check current clicks. */\n  private _scheduleCheckClicks(): void {\n    if (this._checkClickTimeout) {\n      clearTimeout(this._checkClickTimeout);\n    }\n\n    this._checkClickTimeout = setTimeout(() => this._checkClicks(), 1000);\n  }\n}\n\nconst SLOW_CLICK_TAGS = ['A', 'BUTTON', 'INPUT'];\n\n/** exported for tests only */\nexport function ignoreElement(node: HTMLElement, ignoreSelector: string): boolean {\n  if (!SLOW_CLICK_TAGS.includes(node.tagName)) {\n    return true;\n  }\n\n  // If <input> tag, we only want to consider input[type='submit'] & input[type='button']\n  if (node.tagName === 'INPUT' && !['submit', 'button'].includes(node.getAttribute('type') || '')) {\n    return true;\n  }\n\n  // If <a> tag, detect special variants that may not lead to an action\n  // If target !== _self, we may open the link somewhere else, which would lead to no action\n  // Also, when downloading a file, we may not leave the page, but still not trigger an action\n  if (\n    node.tagName === 'A' &&\n    (node.hasAttribute('download') || (node.hasAttribute('target') && node.getAttribute('target') !== '_self'))\n  ) {\n    return true;\n  }\n\n  if (ignoreSelector && node.matches(ignoreSelector)) {\n    return true;\n  }\n\n  return false;\n}\n\nfunction isClickBreadcrumb(breadcrumb: Breadcrumb): breadcrumb is ClickBreadcrumb {\n  return !!(breadcrumb.data && typeof breadcrumb.data.nodeId === 'number' && breadcrumb.timestamp);\n}\n\n// This is good enough for us, and is easier to test/mock than `timestampInSeconds`\nfunction nowInSeconds(): number {\n  return Date.now() / 1000;\n}\n\n/** Update the click detector based on a recording event of rrweb. */\nexport function updateClickDetectorForRecordingEvent(clickDetector: ReplayClickDetector, event: RecordingEvent): void {\n  try {\n    // note: We only consider incremental snapshots here\n    // This means that any full snapshot is ignored for mutation detection - the reason is that we simply cannot know if a mutation happened here.\n    // E.g. think that we are buffering, an error happens and we take a full snapshot because we switched to session mode -\n    // in this scenario, we would not know if a dead click happened because of the error, which is a key dead click scenario.\n    // Instead, by ignoring full snapshots, we have the risk that we generate a false positive\n    // (if a mutation _did_ happen but was \"swallowed\" by the full snapshot)\n    // But this should be more unlikely as we'd generally capture the incremental snapshot right away\n\n    if (!isIncrementalEvent(event)) {\n      return;\n    }\n\n    const { source } = event.data;\n    if (source === IncrementalSource.Mutation) {\n      clickDetector.registerMutation(event.timestamp);\n    }\n\n    if (source === IncrementalSource.Scroll) {\n      clickDetector.registerScroll(event.timestamp);\n    }\n\n    if (isIncrementalMouseInteraction(event)) {\n      const { type, id } = event.data;\n      const node = record.mirror.getNode(id);\n\n      if (node instanceof HTMLElement && type === MouseInteractions.Click) {\n        clickDetector.registerClick(node);\n      }\n    }\n  } catch {\n    // ignore errors here, e.g. if accessing something that does not exist\n  }\n}\n\nfunction isIncrementalEvent(event: RecordingEvent): event is IncrementalRecordingEvent {\n  return event.type === ReplayEventTypeIncrementalSnapshot;\n}\n\nfunction isIncrementalMouseInteraction(\n  event: IncrementalRecordingEvent,\n): event is IncrementalMouseInteractionRecordingEvent {\n  return event.data.source === IncrementalSource.MouseInteraction;\n}\n","var NodeType;\r\n(function (NodeType) {\r\n    NodeType[NodeType[\"Document\"] = 0] = \"Document\";\r\n    NodeType[NodeType[\"DocumentType\"] = 1] = \"DocumentType\";\r\n    NodeType[NodeType[\"Element\"] = 2] = \"Element\";\r\n    NodeType[NodeType[\"Text\"] = 3] = \"Text\";\r\n    NodeType[NodeType[\"CDATA\"] = 4] = \"CDATA\";\r\n    NodeType[NodeType[\"Comment\"] = 5] = \"Comment\";\r\n})(NodeType || (NodeType = {}));\n\nfunction isElement(n) {\r\n    return n.nodeType === n.ELEMENT_NODE;\r\n}\r\nfunction isShadowRoot(n) {\r\n    const host = n?.host;\r\n    return Boolean(host?.shadowRoot === n);\r\n}\r\nfunction isNativeShadowDom(shadowRoot) {\r\n    return Object.prototype.toString.call(shadowRoot) === '[object ShadowRoot]';\r\n}\r\nfunction fixBrowserCompatibilityIssuesInCSS(cssText) {\r\n    if (cssText.includes(' background-clip: text;') &&\r\n        !cssText.includes(' -webkit-background-clip: text;')) {\r\n        cssText = cssText.replace(' background-clip: text;', ' -webkit-background-clip: text; background-clip: text;');\r\n    }\r\n    return cssText;\r\n}\r\nfunction escapeImportStatement(rule) {\r\n    const { cssText } = rule;\r\n    if (cssText.split('\"').length < 3)\r\n        return cssText;\r\n    const statement = ['@import', `url(${JSON.stringify(rule.href)})`];\r\n    if (rule.layerName === '') {\r\n        statement.push(`layer`);\r\n    }\r\n    else if (rule.layerName) {\r\n        statement.push(`layer(${rule.layerName})`);\r\n    }\r\n    if (rule.supportsText) {\r\n        statement.push(`supports(${rule.supportsText})`);\r\n    }\r\n    if (rule.media.length) {\r\n        statement.push(rule.media.mediaText);\r\n    }\r\n    return statement.join(' ') + ';';\r\n}\r\nfunction stringifyStylesheet(s) {\r\n    try {\r\n        const rules = s.rules || s.cssRules;\r\n        return rules\r\n            ? fixBrowserCompatibilityIssuesInCSS(Array.from(rules, stringifyRule).join(''))\r\n            : null;\r\n    }\r\n    catch (error) {\r\n        return null;\r\n    }\r\n}\r\nfunction stringifyRule(rule) {\r\n    let importStringified;\r\n    if (isCSSImportRule(rule)) {\r\n        try {\r\n            importStringified =\r\n                stringifyStylesheet(rule.styleSheet) ||\r\n                    escapeImportStatement(rule);\r\n        }\r\n        catch (error) {\r\n        }\r\n    }\r\n    else if (isCSSStyleRule(rule) && rule.selectorText.includes(':')) {\r\n        return fixSafariColons(rule.cssText);\r\n    }\r\n    return importStringified || rule.cssText;\r\n}\r\nfunction fixSafariColons(cssStringified) {\r\n    const regex = /(\\[(?:[\\w-]+)[^\\\\])(:(?:[\\w-]+)\\])/gm;\r\n    return cssStringified.replace(regex, '$1\\\\$2');\r\n}\r\nfunction isCSSImportRule(rule) {\r\n    return 'styleSheet' in rule;\r\n}\r\nfunction isCSSStyleRule(rule) {\r\n    return 'selectorText' in rule;\r\n}\r\nclass Mirror {\r\n    constructor() {\r\n        this.idNodeMap = new Map();\r\n        this.nodeMetaMap = new WeakMap();\r\n    }\r\n    getId(n) {\r\n        if (!n)\r\n            return -1;\r\n        const id = this.getMeta(n)?.id;\r\n        return id ?? -1;\r\n    }\r\n    getNode(id) {\r\n        return this.idNodeMap.get(id) || null;\r\n    }\r\n    getIds() {\r\n        return Array.from(this.idNodeMap.keys());\r\n    }\r\n    getMeta(n) {\r\n        return this.nodeMetaMap.get(n) || null;\r\n    }\r\n    removeNodeFromMap(n) {\r\n        const id = this.getId(n);\r\n        this.idNodeMap.delete(id);\r\n        if (n.childNodes) {\r\n            n.childNodes.forEach((childNode) => this.removeNodeFromMap(childNode));\r\n        }\r\n    }\r\n    has(id) {\r\n        return this.idNodeMap.has(id);\r\n    }\r\n    hasNode(node) {\r\n        return this.nodeMetaMap.has(node);\r\n    }\r\n    add(n, meta) {\r\n        const id = meta.id;\r\n        this.idNodeMap.set(id, n);\r\n        this.nodeMetaMap.set(n, meta);\r\n    }\r\n    replace(id, n) {\r\n        const oldNode = this.getNode(id);\r\n        if (oldNode) {\r\n            const meta = this.nodeMetaMap.get(oldNode);\r\n            if (meta)\r\n                this.nodeMetaMap.set(n, meta);\r\n        }\r\n        this.idNodeMap.set(id, n);\r\n    }\r\n    reset() {\r\n        this.idNodeMap = new Map();\r\n        this.nodeMetaMap = new WeakMap();\r\n    }\r\n}\r\nfunction createMirror() {\r\n    return new Mirror();\r\n}\r\nfunction shouldMaskInput({ maskInputOptions, tagName, type, }) {\r\n    if (tagName === 'OPTION') {\r\n        tagName = 'SELECT';\r\n    }\r\n    return Boolean(maskInputOptions[tagName.toLowerCase()] ||\r\n        (type && maskInputOptions[type]) ||\r\n        type === 'password' ||\r\n        (tagName === 'INPUT' && !type && maskInputOptions['text']));\r\n}\r\nfunction maskInputValue({ isMasked, element, value, maskInputFn, }) {\r\n    let text = value || '';\r\n    if (!isMasked) {\r\n        return text;\r\n    }\r\n    if (maskInputFn) {\r\n        text = maskInputFn(text, element);\r\n    }\r\n    return '*'.repeat(text.length);\r\n}\r\nfunction toLowerCase(str) {\r\n    return str.toLowerCase();\r\n}\r\nfunction toUpperCase(str) {\r\n    return str.toUpperCase();\r\n}\r\nconst ORIGINAL_ATTRIBUTE_NAME = '__rrweb_original__';\r\nfunction is2DCanvasBlank(canvas) {\r\n    const ctx = canvas.getContext('2d');\r\n    if (!ctx)\r\n        return true;\r\n    const chunkSize = 50;\r\n    for (let x = 0; x < canvas.width; x += chunkSize) {\r\n        for (let y = 0; y < canvas.height; y += chunkSize) {\r\n            const getImageData = ctx.getImageData;\r\n            const originalGetImageData = ORIGINAL_ATTRIBUTE_NAME in getImageData\r\n                ? getImageData[ORIGINAL_ATTRIBUTE_NAME]\r\n                : getImageData;\r\n            const pixelBuffer = new Uint32Array(originalGetImageData.call(ctx, x, y, Math.min(chunkSize, canvas.width - x), Math.min(chunkSize, canvas.height - y)).data.buffer);\r\n            if (pixelBuffer.some((pixel) => pixel !== 0))\r\n                return false;\r\n        }\r\n    }\r\n    return true;\r\n}\r\nfunction isNodeMetaEqual(a, b) {\r\n    if (!a || !b || a.type !== b.type)\r\n        return false;\r\n    if (a.type === NodeType.Document)\r\n        return a.compatMode === b.compatMode;\r\n    else if (a.type === NodeType.DocumentType)\r\n        return (a.name === b.name &&\r\n            a.publicId === b.publicId &&\r\n            a.systemId === b.systemId);\r\n    else if (a.type === NodeType.Comment ||\r\n        a.type === NodeType.Text ||\r\n        a.type === NodeType.CDATA)\r\n        return a.textContent === b.textContent;\r\n    else if (a.type === NodeType.Element)\r\n        return (a.tagName === b.tagName &&\r\n            JSON.stringify(a.attributes) ===\r\n                JSON.stringify(b.attributes) &&\r\n            a.isSVG === b.isSVG &&\r\n            a.needBlock === b.needBlock);\r\n    return false;\r\n}\r\nfunction getInputType(element) {\r\n    const type = element.type;\r\n    return element.hasAttribute('data-rr-is-password')\r\n        ? 'password'\r\n        : type\r\n            ?\r\n                toLowerCase(type)\r\n            : null;\r\n}\r\nfunction getInputValue(el, tagName, type) {\r\n    if (tagName === 'INPUT' && (type === 'radio' || type === 'checkbox')) {\r\n        return el.getAttribute('value') || '';\r\n    }\r\n    return el.value;\r\n}\n\nlet _id = 1;\r\nconst tagNameRegex = new RegExp('[^a-z0-9-_:]');\r\nconst IGNORED_NODE = -2;\r\nfunction genId() {\r\n    return _id++;\r\n}\r\nfunction getValidTagName(element) {\r\n    if (element instanceof HTMLFormElement) {\r\n        return 'form';\r\n    }\r\n    const processedTagName = toLowerCase(element.tagName);\r\n    if (tagNameRegex.test(processedTagName)) {\r\n        return 'div';\r\n    }\r\n    return processedTagName;\r\n}\r\nfunction extractOrigin(url) {\r\n    let origin = '';\r\n    if (url.indexOf('//') > -1) {\r\n        origin = url.split('/').slice(0, 3).join('/');\r\n    }\r\n    else {\r\n        origin = url.split('/')[0];\r\n    }\r\n    origin = origin.split('?')[0];\r\n    return origin;\r\n}\r\nlet canvasService;\r\nlet canvasCtx;\r\nconst URL_IN_CSS_REF = /url\\((?:(')([^']*)'|(\")(.*?)\"|([^)]*))\\)/gm;\r\nconst URL_PROTOCOL_MATCH = /^(?:[a-z+]+:)?\\/\\//i;\r\nconst URL_WWW_MATCH = /^www\\..*/i;\r\nconst DATA_URI = /^(data:)([^,]*),(.*)/i;\r\nfunction absoluteToStylesheet(cssText, href) {\r\n    return (cssText || '').replace(URL_IN_CSS_REF, (origin, quote1, path1, quote2, path2, path3) => {\r\n        const filePath = path1 || path2 || path3;\r\n        const maybeQuote = quote1 || quote2 || '';\r\n        if (!filePath) {\r\n            return origin;\r\n        }\r\n        if (URL_PROTOCOL_MATCH.test(filePath) || URL_WWW_MATCH.test(filePath)) {\r\n            return `url(${maybeQuote}${filePath}${maybeQuote})`;\r\n        }\r\n        if (DATA_URI.test(filePath)) {\r\n            return `url(${maybeQuote}${filePath}${maybeQuote})`;\r\n        }\r\n        if (filePath[0] === '/') {\r\n            return `url(${maybeQuote}${extractOrigin(href) + filePath}${maybeQuote})`;\r\n        }\r\n        const stack = href.split('/');\r\n        const parts = filePath.split('/');\r\n        stack.pop();\r\n        for (const part of parts) {\r\n            if (part === '.') {\r\n                continue;\r\n            }\r\n            else if (part === '..') {\r\n                stack.pop();\r\n            }\r\n            else {\r\n                stack.push(part);\r\n            }\r\n        }\r\n        return `url(${maybeQuote}${stack.join('/')}${maybeQuote})`;\r\n    });\r\n}\r\nconst SRCSET_NOT_SPACES = /^[^ \\t\\n\\r\\u000c]+/;\r\nconst SRCSET_COMMAS_OR_SPACES = /^[, \\t\\n\\r\\u000c]+/;\r\nfunction getAbsoluteSrcsetString(doc, attributeValue) {\r\n    if (attributeValue.trim() === '') {\r\n        return attributeValue;\r\n    }\r\n    let pos = 0;\r\n    function collectCharacters(regEx) {\r\n        let chars;\r\n        const match = regEx.exec(attributeValue.substring(pos));\r\n        if (match) {\r\n            chars = match[0];\r\n            pos += chars.length;\r\n            return chars;\r\n        }\r\n        return '';\r\n    }\r\n    const output = [];\r\n    while (true) {\r\n        collectCharacters(SRCSET_COMMAS_OR_SPACES);\r\n        if (pos >= attributeValue.length) {\r\n            break;\r\n        }\r\n        let url = collectCharacters(SRCSET_NOT_SPACES);\r\n        if (url.slice(-1) === ',') {\r\n            url = absoluteToDoc(doc, url.substring(0, url.length - 1));\r\n            output.push(url);\r\n        }\r\n        else {\r\n            let descriptorsStr = '';\r\n            url = absoluteToDoc(doc, url);\r\n            let inParens = false;\r\n            while (true) {\r\n                const c = attributeValue.charAt(pos);\r\n                if (c === '') {\r\n                    output.push((url + descriptorsStr).trim());\r\n                    break;\r\n                }\r\n                else if (!inParens) {\r\n                    if (c === ',') {\r\n                        pos += 1;\r\n                        output.push((url + descriptorsStr).trim());\r\n                        break;\r\n                    }\r\n                    else if (c === '(') {\r\n                        inParens = true;\r\n                    }\r\n                }\r\n                else {\r\n                    if (c === ')') {\r\n                        inParens = false;\r\n                    }\r\n                }\r\n                descriptorsStr += c;\r\n                pos += 1;\r\n            }\r\n        }\r\n    }\r\n    return output.join(', ');\r\n}\r\nfunction absoluteToDoc(doc, attributeValue) {\r\n    if (!attributeValue || attributeValue.trim() === '') {\r\n        return attributeValue;\r\n    }\r\n    const a = doc.createElement('a');\r\n    a.href = attributeValue;\r\n    return a.href;\r\n}\r\nfunction isSVGElement(el) {\r\n    return Boolean(el.tagName === 'svg' || el.ownerSVGElement);\r\n}\r\nfunction getHref() {\r\n    const a = document.createElement('a');\r\n    a.href = '';\r\n    return a.href;\r\n}\r\nfunction transformAttribute(doc, tagName, name, value, element, maskAttributeFn) {\r\n    if (!value) {\r\n        return value;\r\n    }\r\n    if (name === 'src' ||\r\n        (name === 'href' && !(tagName === 'use' && value[0] === '#'))) {\r\n        return absoluteToDoc(doc, value);\r\n    }\r\n    else if (name === 'xlink:href' && value[0] !== '#') {\r\n        return absoluteToDoc(doc, value);\r\n    }\r\n    else if (name === 'background' &&\r\n        (tagName === 'table' || tagName === 'td' || tagName === 'th')) {\r\n        return absoluteToDoc(doc, value);\r\n    }\r\n    else if (name === 'srcset') {\r\n        return getAbsoluteSrcsetString(doc, value);\r\n    }\r\n    else if (name === 'style') {\r\n        return absoluteToStylesheet(value, getHref());\r\n    }\r\n    else if (tagName === 'object' && name === 'data') {\r\n        return absoluteToDoc(doc, value);\r\n    }\r\n    if (typeof maskAttributeFn === 'function') {\r\n        return maskAttributeFn(name, value, element);\r\n    }\r\n    return value;\r\n}\r\nfunction ignoreAttribute(tagName, name, _value) {\r\n    return (tagName === 'video' || tagName === 'audio') && name === 'autoplay';\r\n}\r\nfunction _isBlockedElement(element, blockClass, blockSelector, unblockSelector) {\r\n    try {\r\n        if (unblockSelector && element.matches(unblockSelector)) {\r\n            return false;\r\n        }\r\n        if (typeof blockClass === 'string') {\r\n            if (element.classList.contains(blockClass)) {\r\n                return true;\r\n            }\r\n        }\r\n        else {\r\n            for (let eIndex = element.classList.length; eIndex--;) {\r\n                const className = element.classList[eIndex];\r\n                if (blockClass.test(className)) {\r\n                    return true;\r\n                }\r\n            }\r\n        }\r\n        if (blockSelector) {\r\n            return element.matches(blockSelector);\r\n        }\r\n    }\r\n    catch (e) {\r\n    }\r\n    return false;\r\n}\r\nfunction elementClassMatchesRegex(el, regex) {\r\n    for (let eIndex = el.classList.length; eIndex--;) {\r\n        const className = el.classList[eIndex];\r\n        if (regex.test(className)) {\r\n            return true;\r\n        }\r\n    }\r\n    return false;\r\n}\r\nfunction classMatchesRegex(node, regex, checkAncestors) {\r\n    if (!node)\r\n        return false;\r\n    if (checkAncestors) {\r\n        return (distanceToMatch(node, (node) => elementClassMatchesRegex(node, regex)) >= 0);\r\n    }\r\n    else if (node.nodeType === node.ELEMENT_NODE) {\r\n        return elementClassMatchesRegex(node, regex);\r\n    }\r\n    return false;\r\n}\r\nfunction distanceToMatch(node, matchPredicate, limit = Infinity, distance = 0) {\r\n    if (!node)\r\n        return -1;\r\n    if (node.nodeType !== node.ELEMENT_NODE)\r\n        return -1;\r\n    if (distance > limit)\r\n        return -1;\r\n    if (matchPredicate(node))\r\n        return distance;\r\n    return distanceToMatch(node.parentNode, matchPredicate, limit, distance + 1);\r\n}\r\nfunction createMatchPredicate(className, selector) {\r\n    return (node) => {\r\n        const el = node;\r\n        if (el === null)\r\n            return false;\r\n        try {\r\n            if (className) {\r\n                if (typeof className === 'string') {\r\n                    if (el.matches(`.${className}`))\r\n                        return true;\r\n                }\r\n                else if (elementClassMatchesRegex(el, className)) {\r\n                    return true;\r\n                }\r\n            }\r\n            if (selector && el.matches(selector))\r\n                return true;\r\n            return false;\r\n        }\r\n        catch {\r\n            return false;\r\n        }\r\n    };\r\n}\r\nfunction needMaskingText(node, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, maskAllText) {\r\n    try {\r\n        const el = node.nodeType === node.ELEMENT_NODE\r\n            ? node\r\n            : node.parentElement;\r\n        if (el === null)\r\n            return false;\r\n        if (el.tagName === 'INPUT') {\r\n            const autocomplete = el.getAttribute('autocomplete');\r\n            const disallowedAutocompleteValues = [\r\n                'current-password',\r\n                'new-password',\r\n                'cc-number',\r\n                'cc-exp',\r\n                'cc-exp-month',\r\n                'cc-exp-year',\r\n                'cc-csc',\r\n            ];\r\n            if (disallowedAutocompleteValues.includes(autocomplete)) {\r\n                return true;\r\n            }\r\n        }\r\n        let maskDistance = -1;\r\n        let unmaskDistance = -1;\r\n        if (maskAllText) {\r\n            unmaskDistance = distanceToMatch(el, createMatchPredicate(unmaskTextClass, unmaskTextSelector));\r\n            if (unmaskDistance < 0) {\r\n                return true;\r\n            }\r\n            maskDistance = distanceToMatch(el, createMatchPredicate(maskTextClass, maskTextSelector), unmaskDistance >= 0 ? unmaskDistance : Infinity);\r\n        }\r\n        else {\r\n            maskDistance = distanceToMatch(el, createMatchPredicate(maskTextClass, maskTextSelector));\r\n            if (maskDistance < 0) {\r\n                return false;\r\n            }\r\n            unmaskDistance = distanceToMatch(el, createMatchPredicate(unmaskTextClass, unmaskTextSelector), maskDistance >= 0 ? maskDistance : Infinity);\r\n        }\r\n        return maskDistance >= 0\r\n            ? unmaskDistance >= 0\r\n                ? maskDistance <= unmaskDistance\r\n                : true\r\n            : unmaskDistance >= 0\r\n                ? false\r\n                : !!maskAllText;\r\n    }\r\n    catch (e) {\r\n    }\r\n    return !!maskAllText;\r\n}\r\nfunction onceIframeLoaded(iframeEl, listener, iframeLoadTimeout) {\r\n    const win = iframeEl.contentWindow;\r\n    if (!win) {\r\n        return;\r\n    }\r\n    let fired = false;\r\n    let readyState;\r\n    try {\r\n        readyState = win.document.readyState;\r\n    }\r\n    catch (error) {\r\n        return;\r\n    }\r\n    if (readyState !== 'complete') {\r\n        const timer = setTimeout(() => {\r\n            if (!fired) {\r\n                listener();\r\n                fired = true;\r\n            }\r\n        }, iframeLoadTimeout);\r\n        iframeEl.addEventListener('load', () => {\r\n            clearTimeout(timer);\r\n            fired = true;\r\n            listener();\r\n        });\r\n        return;\r\n    }\r\n    const blankUrl = 'about:blank';\r\n    if (win.location.href !== blankUrl ||\r\n        iframeEl.src === blankUrl ||\r\n        iframeEl.src === '') {\r\n        setTimeout(listener, 0);\r\n        return iframeEl.addEventListener('load', listener);\r\n    }\r\n    iframeEl.addEventListener('load', listener);\r\n}\r\nfunction onceStylesheetLoaded(link, listener, styleSheetLoadTimeout) {\r\n    let fired = false;\r\n    let styleSheetLoaded;\r\n    try {\r\n        styleSheetLoaded = link.sheet;\r\n    }\r\n    catch (error) {\r\n        return;\r\n    }\r\n    if (styleSheetLoaded)\r\n        return;\r\n    const timer = setTimeout(() => {\r\n        if (!fired) {\r\n            listener();\r\n            fired = true;\r\n        }\r\n    }, styleSheetLoadTimeout);\r\n    link.addEventListener('load', () => {\r\n        clearTimeout(timer);\r\n        fired = true;\r\n        listener();\r\n    });\r\n}\r\nfunction serializeNode(n, options) {\r\n    const { doc, mirror, blockClass, blockSelector, unblockSelector, maskAllText, maskAttributeFn, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, inlineStylesheet, maskInputOptions = {}, maskTextFn, maskInputFn, dataURLOptions = {}, inlineImages, recordCanvas, keepIframeSrcFn, newlyAddedElement = false, } = options;\r\n    const rootId = getRootId(doc, mirror);\r\n    switch (n.nodeType) {\r\n        case n.DOCUMENT_NODE:\r\n            if (n.compatMode !== 'CSS1Compat') {\r\n                return {\r\n                    type: NodeType.Document,\r\n                    childNodes: [],\r\n                    compatMode: n.compatMode,\r\n                };\r\n            }\r\n            else {\r\n                return {\r\n                    type: NodeType.Document,\r\n                    childNodes: [],\r\n                };\r\n            }\r\n        case n.DOCUMENT_TYPE_NODE:\r\n            return {\r\n                type: NodeType.DocumentType,\r\n                name: n.name,\r\n                publicId: n.publicId,\r\n                systemId: n.systemId,\r\n                rootId,\r\n            };\r\n        case n.ELEMENT_NODE:\r\n            return serializeElementNode(n, {\r\n                doc,\r\n                blockClass,\r\n                blockSelector,\r\n                unblockSelector,\r\n                inlineStylesheet,\r\n                maskAttributeFn,\r\n                maskInputOptions,\r\n                maskInputFn,\r\n                dataURLOptions,\r\n                inlineImages,\r\n                recordCanvas,\r\n                keepIframeSrcFn,\r\n                newlyAddedElement,\r\n                rootId,\r\n                maskAllText,\r\n                maskTextClass,\r\n                unmaskTextClass,\r\n                maskTextSelector,\r\n                unmaskTextSelector,\r\n            });\r\n        case n.TEXT_NODE:\r\n            return serializeTextNode(n, {\r\n                maskAllText,\r\n                maskTextClass,\r\n                unmaskTextClass,\r\n                maskTextSelector,\r\n                unmaskTextSelector,\r\n                maskTextFn,\r\n                maskInputOptions,\r\n                maskInputFn,\r\n                rootId,\r\n            });\r\n        case n.CDATA_SECTION_NODE:\r\n            return {\r\n                type: NodeType.CDATA,\r\n                textContent: '',\r\n                rootId,\r\n            };\r\n        case n.COMMENT_NODE:\r\n            return {\r\n                type: NodeType.Comment,\r\n                textContent: n.textContent || '',\r\n                rootId,\r\n            };\r\n        default:\r\n            return false;\r\n    }\r\n}\r\nfunction getRootId(doc, mirror) {\r\n    if (!mirror.hasNode(doc))\r\n        return undefined;\r\n    const docId = mirror.getId(doc);\r\n    return docId === 1 ? undefined : docId;\r\n}\r\nfunction serializeTextNode(n, options) {\r\n    const { maskAllText, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, maskTextFn, maskInputOptions, maskInputFn, rootId, } = options;\r\n    const parentTagName = n.parentNode && n.parentNode.tagName;\r\n    let textContent = n.textContent;\r\n    const isStyle = parentTagName === 'STYLE' ? true : undefined;\r\n    const isScript = parentTagName === 'SCRIPT' ? true : undefined;\r\n    const isTextarea = parentTagName === 'TEXTAREA' ? true : undefined;\r\n    if (isStyle && textContent) {\r\n        try {\r\n            if (n.nextSibling || n.previousSibling) {\r\n            }\r\n            else if (n.parentNode.sheet?.cssRules) {\r\n                textContent = stringifyStylesheet(n.parentNode.sheet);\r\n            }\r\n        }\r\n        catch (err) {\r\n            console.warn(`Cannot get CSS styles from text's parentNode. Error: ${err}`, n);\r\n        }\r\n        textContent = absoluteToStylesheet(textContent, getHref());\r\n    }\r\n    if (isScript) {\r\n        textContent = 'SCRIPT_PLACEHOLDER';\r\n    }\r\n    const forceMask = needMaskingText(n, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, maskAllText);\r\n    if (!isStyle && !isScript && !isTextarea && textContent && forceMask) {\r\n        textContent = maskTextFn\r\n            ? maskTextFn(textContent, n.parentElement)\r\n            : textContent.replace(/[\\S]/g, '*');\r\n    }\r\n    if (isTextarea && textContent && (maskInputOptions.textarea || forceMask)) {\r\n        textContent = maskInputFn\r\n            ? maskInputFn(textContent, n.parentNode)\r\n            : textContent.replace(/[\\S]/g, '*');\r\n    }\r\n    if (parentTagName === 'OPTION' && textContent) {\r\n        const isInputMasked = shouldMaskInput({\r\n            type: null,\r\n            tagName: parentTagName,\r\n            maskInputOptions,\r\n        });\r\n        textContent = maskInputValue({\r\n            isMasked: needMaskingText(n, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, isInputMasked),\r\n            element: n,\r\n            value: textContent,\r\n            maskInputFn,\r\n        });\r\n    }\r\n    return {\r\n        type: NodeType.Text,\r\n        textContent: textContent || '',\r\n        isStyle,\r\n        rootId,\r\n    };\r\n}\r\nfunction serializeElementNode(n, options) {\r\n    const { doc, blockClass, blockSelector, unblockSelector, inlineStylesheet, maskInputOptions = {}, maskAttributeFn, maskInputFn, dataURLOptions = {}, inlineImages, recordCanvas, keepIframeSrcFn, newlyAddedElement = false, rootId, maskAllText, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, } = options;\r\n    const needBlock = _isBlockedElement(n, blockClass, blockSelector, unblockSelector);\r\n    const tagName = getValidTagName(n);\r\n    let attributes = {};\r\n    const len = n.attributes.length;\r\n    for (let i = 0; i < len; i++) {\r\n        const attr = n.attributes[i];\r\n        if (attr.name && !ignoreAttribute(tagName, attr.name, attr.value)) {\r\n            attributes[attr.name] = transformAttribute(doc, tagName, toLowerCase(attr.name), attr.value, n, maskAttributeFn);\r\n        }\r\n    }\r\n    if (tagName === 'link' && inlineStylesheet) {\r\n        const stylesheet = Array.from(doc.styleSheets).find((s) => {\r\n            return s.href === n.href;\r\n        });\r\n        let cssText = null;\r\n        if (stylesheet) {\r\n            cssText = stringifyStylesheet(stylesheet);\r\n        }\r\n        if (cssText) {\r\n            delete attributes.rel;\r\n            delete attributes.href;\r\n            attributes._cssText = absoluteToStylesheet(cssText, stylesheet.href);\r\n        }\r\n    }\r\n    if (tagName === 'style' &&\r\n        n.sheet &&\r\n        !(n.innerText || n.textContent || '').trim().length) {\r\n        const cssText = stringifyStylesheet(n.sheet);\r\n        if (cssText) {\r\n            attributes._cssText = absoluteToStylesheet(cssText, getHref());\r\n        }\r\n    }\r\n    if (tagName === 'input' ||\r\n        tagName === 'textarea' ||\r\n        tagName === 'select' ||\r\n        tagName === 'option') {\r\n        const el = n;\r\n        const type = getInputType(el);\r\n        const value = getInputValue(el, toUpperCase(tagName), type);\r\n        const checked = el.checked;\r\n        if (type !== 'submit' && type !== 'button' && value) {\r\n            const forceMask = needMaskingText(el, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, shouldMaskInput({\r\n                type,\r\n                tagName: toUpperCase(tagName),\r\n                maskInputOptions,\r\n            }));\r\n            attributes.value = maskInputValue({\r\n                isMasked: forceMask,\r\n                element: el,\r\n                value,\r\n                maskInputFn,\r\n            });\r\n        }\r\n        if (checked) {\r\n            attributes.checked = checked;\r\n        }\r\n    }\r\n    if (tagName === 'option') {\r\n        if (n.selected && !maskInputOptions['select']) {\r\n            attributes.selected = true;\r\n        }\r\n        else {\r\n            delete attributes.selected;\r\n        }\r\n    }\r\n    if (tagName === 'canvas' && recordCanvas) {\r\n        if (n.__context === '2d') {\r\n            if (!is2DCanvasBlank(n)) {\r\n                attributes.rr_dataURL = n.toDataURL(dataURLOptions.type, dataURLOptions.quality);\r\n            }\r\n        }\r\n        else if (!('__context' in n)) {\r\n            const canvasDataURL = n.toDataURL(dataURLOptions.type, dataURLOptions.quality);\r\n            const blankCanvas = document.createElement('canvas');\r\n            blankCanvas.width = n.width;\r\n            blankCanvas.height = n.height;\r\n            const blankCanvasDataURL = blankCanvas.toDataURL(dataURLOptions.type, dataURLOptions.quality);\r\n            if (canvasDataURL !== blankCanvasDataURL) {\r\n                attributes.rr_dataURL = canvasDataURL;\r\n            }\r\n        }\r\n    }\r\n    if (tagName === 'img' && inlineImages) {\r\n        if (!canvasService) {\r\n            canvasService = doc.createElement('canvas');\r\n            canvasCtx = canvasService.getContext('2d');\r\n        }\r\n        const image = n;\r\n        const oldValue = image.crossOrigin;\r\n        image.crossOrigin = 'anonymous';\r\n        const recordInlineImage = () => {\r\n            image.removeEventListener('load', recordInlineImage);\r\n            try {\r\n                canvasService.width = image.naturalWidth;\r\n                canvasService.height = image.naturalHeight;\r\n                canvasCtx.drawImage(image, 0, 0);\r\n                attributes.rr_dataURL = canvasService.toDataURL(dataURLOptions.type, dataURLOptions.quality);\r\n            }\r\n            catch (err) {\r\n                console.warn(`Cannot inline img src=${image.currentSrc}! Error: ${err}`);\r\n            }\r\n            oldValue\r\n                ? (attributes.crossOrigin = oldValue)\r\n                : image.removeAttribute('crossorigin');\r\n        };\r\n        if (image.complete && image.naturalWidth !== 0)\r\n            recordInlineImage();\r\n        else\r\n            image.addEventListener('load', recordInlineImage);\r\n    }\r\n    if (tagName === 'audio' || tagName === 'video') {\r\n        attributes.rr_mediaState = n.paused\r\n            ? 'paused'\r\n            : 'played';\r\n        attributes.rr_mediaCurrentTime = n.currentTime;\r\n    }\r\n    if (!newlyAddedElement) {\r\n        if (n.scrollLeft) {\r\n            attributes.rr_scrollLeft = n.scrollLeft;\r\n        }\r\n        if (n.scrollTop) {\r\n            attributes.rr_scrollTop = n.scrollTop;\r\n        }\r\n    }\r\n    if (needBlock) {\r\n        const { width, height } = n.getBoundingClientRect();\r\n        attributes = {\r\n            class: attributes.class,\r\n            rr_width: `${width}px`,\r\n            rr_height: `${height}px`,\r\n        };\r\n    }\r\n    if (tagName === 'iframe' && !keepIframeSrcFn(attributes.src)) {\r\n        if (!n.contentDocument) {\r\n            attributes.rr_src = attributes.src;\r\n        }\r\n        delete attributes.src;\r\n    }\r\n    let isCustomElement;\r\n    try {\r\n        if (customElements.get(tagName))\r\n            isCustomElement = true;\r\n    }\r\n    catch (e) {\r\n    }\r\n    return {\r\n        type: NodeType.Element,\r\n        tagName,\r\n        attributes,\r\n        childNodes: [],\r\n        isSVG: isSVGElement(n) || undefined,\r\n        needBlock,\r\n        rootId,\r\n        isCustom: isCustomElement,\r\n    };\r\n}\r\nfunction lowerIfExists(maybeAttr) {\r\n    if (maybeAttr === undefined || maybeAttr === null) {\r\n        return '';\r\n    }\r\n    else {\r\n        return maybeAttr.toLowerCase();\r\n    }\r\n}\r\nfunction slimDOMExcluded(sn, slimDOMOptions) {\r\n    if (slimDOMOptions.comment && sn.type === NodeType.Comment) {\r\n        return true;\r\n    }\r\n    else if (sn.type === NodeType.Element) {\r\n        if (slimDOMOptions.script &&\r\n            (sn.tagName === 'script' ||\r\n                (sn.tagName === 'link' &&\r\n                    (sn.attributes.rel === 'preload' ||\r\n                        sn.attributes.rel === 'modulepreload') &&\r\n                    sn.attributes.as === 'script') ||\r\n                (sn.tagName === 'link' &&\r\n                    sn.attributes.rel === 'prefetch' &&\r\n                    typeof sn.attributes.href === 'string' &&\r\n                    sn.attributes.href.endsWith('.js')))) {\r\n            return true;\r\n        }\r\n        else if (slimDOMOptions.headFavicon &&\r\n            ((sn.tagName === 'link' && sn.attributes.rel === 'shortcut icon') ||\r\n                (sn.tagName === 'meta' &&\r\n                    (lowerIfExists(sn.attributes.name).match(/^msapplication-tile(image|color)$/) ||\r\n                        lowerIfExists(sn.attributes.name) === 'application-name' ||\r\n                        lowerIfExists(sn.attributes.rel) === 'icon' ||\r\n                        lowerIfExists(sn.attributes.rel) === 'apple-touch-icon' ||\r\n                        lowerIfExists(sn.attributes.rel) === 'shortcut icon')))) {\r\n            return true;\r\n        }\r\n        else if (sn.tagName === 'meta') {\r\n            if (slimDOMOptions.headMetaDescKeywords &&\r\n                lowerIfExists(sn.attributes.name).match(/^description|keywords$/)) {\r\n                return true;\r\n            }\r\n            else if (slimDOMOptions.headMetaSocial &&\r\n                (lowerIfExists(sn.attributes.property).match(/^(og|twitter|fb):/) ||\r\n                    lowerIfExists(sn.attributes.name).match(/^(og|twitter):/) ||\r\n                    lowerIfExists(sn.attributes.name) === 'pinterest')) {\r\n                return true;\r\n            }\r\n            else if (slimDOMOptions.headMetaRobots &&\r\n                (lowerIfExists(sn.attributes.name) === 'robots' ||\r\n                    lowerIfExists(sn.attributes.name) === 'googlebot' ||\r\n                    lowerIfExists(sn.attributes.name) === 'bingbot')) {\r\n                return true;\r\n            }\r\n            else if (slimDOMOptions.headMetaHttpEquiv &&\r\n                sn.attributes['http-equiv'] !== undefined) {\r\n                return true;\r\n            }\r\n            else if (slimDOMOptions.headMetaAuthorship &&\r\n                (lowerIfExists(sn.attributes.name) === 'author' ||\r\n                    lowerIfExists(sn.attributes.name) === 'generator' ||\r\n                    lowerIfExists(sn.attributes.name) === 'framework' ||\r\n                    lowerIfExists(sn.attributes.name) === 'publisher' ||\r\n                    lowerIfExists(sn.attributes.name) === 'progid' ||\r\n                    lowerIfExists(sn.attributes.property).match(/^article:/) ||\r\n                    lowerIfExists(sn.attributes.property).match(/^product:/))) {\r\n                return true;\r\n            }\r\n            else if (slimDOMOptions.headMetaVerification &&\r\n                (lowerIfExists(sn.attributes.name) === 'google-site-verification' ||\r\n                    lowerIfExists(sn.attributes.name) === 'yandex-verification' ||\r\n                    lowerIfExists(sn.attributes.name) === 'csrf-token' ||\r\n                    lowerIfExists(sn.attributes.name) === 'p:domain_verify' ||\r\n                    lowerIfExists(sn.attributes.name) === 'verify-v1' ||\r\n                    lowerIfExists(sn.attributes.name) === 'verification' ||\r\n                    lowerIfExists(sn.attributes.name) === 'shopify-checkout-api-token')) {\r\n                return true;\r\n            }\r\n        }\r\n    }\r\n    return false;\r\n}\r\nfunction serializeNodeWithId(n, options) {\r\n    const { doc, mirror, blockClass, blockSelector, unblockSelector, maskAllText, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, skipChild = false, inlineStylesheet = true, maskInputOptions = {}, maskAttributeFn, maskTextFn, maskInputFn, slimDOMOptions, dataURLOptions = {}, inlineImages = false, recordCanvas = false, onSerialize, onIframeLoad, iframeLoadTimeout = 5000, onStylesheetLoad, stylesheetLoadTimeout = 5000, keepIframeSrcFn = () => false, newlyAddedElement = false, } = options;\r\n    let { preserveWhiteSpace = true } = options;\r\n    const _serializedNode = serializeNode(n, {\r\n        doc,\r\n        mirror,\r\n        blockClass,\r\n        blockSelector,\r\n        maskAllText,\r\n        unblockSelector,\r\n        maskTextClass,\r\n        unmaskTextClass,\r\n        maskTextSelector,\r\n        unmaskTextSelector,\r\n        inlineStylesheet,\r\n        maskInputOptions,\r\n        maskAttributeFn,\r\n        maskTextFn,\r\n        maskInputFn,\r\n        dataURLOptions,\r\n        inlineImages,\r\n        recordCanvas,\r\n        keepIframeSrcFn,\r\n        newlyAddedElement,\r\n    });\r\n    if (!_serializedNode) {\r\n        console.warn(n, 'not serialized');\r\n        return null;\r\n    }\r\n    let id;\r\n    if (mirror.hasNode(n)) {\r\n        id = mirror.getId(n);\r\n    }\r\n    else if (slimDOMExcluded(_serializedNode, slimDOMOptions) ||\r\n        (!preserveWhiteSpace &&\r\n            _serializedNode.type === NodeType.Text &&\r\n            !_serializedNode.isStyle &&\r\n            !_serializedNode.textContent.replace(/^\\s+|\\s+$/gm, '').length)) {\r\n        id = IGNORED_NODE;\r\n    }\r\n    else {\r\n        id = genId();\r\n    }\r\n    const serializedNode = Object.assign(_serializedNode, { id });\r\n    mirror.add(n, serializedNode);\r\n    if (id === IGNORED_NODE) {\r\n        return null;\r\n    }\r\n    if (onSerialize) {\r\n        onSerialize(n);\r\n    }\r\n    let recordChild = !skipChild;\r\n    if (serializedNode.type === NodeType.Element) {\r\n        recordChild = recordChild && !serializedNode.needBlock;\r\n        delete serializedNode.needBlock;\r\n        const shadowRoot = n.shadowRoot;\r\n        if (shadowRoot && isNativeShadowDom(shadowRoot))\r\n            serializedNode.isShadowHost = true;\r\n    }\r\n    if ((serializedNode.type === NodeType.Document ||\r\n        serializedNode.type === NodeType.Element) &&\r\n        recordChild) {\r\n        if (slimDOMOptions.headWhitespace &&\r\n            serializedNode.type === NodeType.Element &&\r\n            serializedNode.tagName === 'head') {\r\n            preserveWhiteSpace = false;\r\n        }\r\n        const bypassOptions = {\r\n            doc,\r\n            mirror,\r\n            blockClass,\r\n            blockSelector,\r\n            maskAllText,\r\n            unblockSelector,\r\n            maskTextClass,\r\n            unmaskTextClass,\r\n            maskTextSelector,\r\n            unmaskTextSelector,\r\n            skipChild,\r\n            inlineStylesheet,\r\n            maskInputOptions,\r\n            maskAttributeFn,\r\n            maskTextFn,\r\n            maskInputFn,\r\n            slimDOMOptions,\r\n            dataURLOptions,\r\n            inlineImages,\r\n            recordCanvas,\r\n            preserveWhiteSpace,\r\n            onSerialize,\r\n            onIframeLoad,\r\n            iframeLoadTimeout,\r\n            onStylesheetLoad,\r\n            stylesheetLoadTimeout,\r\n            keepIframeSrcFn,\r\n        };\r\n        for (const childN of Array.from(n.childNodes)) {\r\n            const serializedChildNode = serializeNodeWithId(childN, bypassOptions);\r\n            if (serializedChildNode) {\r\n                serializedNode.childNodes.push(serializedChildNode);\r\n            }\r\n        }\r\n        if (isElement(n) && n.shadowRoot) {\r\n            for (const childN of Array.from(n.shadowRoot.childNodes)) {\r\n                const serializedChildNode = serializeNodeWithId(childN, bypassOptions);\r\n                if (serializedChildNode) {\r\n                    isNativeShadowDom(n.shadowRoot) &&\r\n                        (serializedChildNode.isShadow = true);\r\n                    serializedNode.childNodes.push(serializedChildNode);\r\n                }\r\n            }\r\n        }\r\n    }\r\n    if (n.parentNode &&\r\n        isShadowRoot(n.parentNode) &&\r\n        isNativeShadowDom(n.parentNode)) {\r\n        serializedNode.isShadow = true;\r\n    }\r\n    if (serializedNode.type === NodeType.Element &&\r\n        serializedNode.tagName === 'iframe') {\r\n        onceIframeLoaded(n, () => {\r\n            const iframeDoc = n.contentDocument;\r\n            if (iframeDoc && onIframeLoad) {\r\n                const serializedIframeNode = serializeNodeWithId(iframeDoc, {\r\n                    doc: iframeDoc,\r\n                    mirror,\r\n                    blockClass,\r\n                    blockSelector,\r\n                    unblockSelector,\r\n                    maskAllText,\r\n                    maskTextClass,\r\n                    unmaskTextClass,\r\n                    maskTextSelector,\r\n                    unmaskTextSelector,\r\n                    skipChild: false,\r\n                    inlineStylesheet,\r\n                    maskInputOptions,\r\n                    maskAttributeFn,\r\n                    maskTextFn,\r\n                    maskInputFn,\r\n                    slimDOMOptions,\r\n                    dataURLOptions,\r\n                    inlineImages,\r\n                    recordCanvas,\r\n                    preserveWhiteSpace,\r\n                    onSerialize,\r\n                    onIframeLoad,\r\n                    iframeLoadTimeout,\r\n                    onStylesheetLoad,\r\n                    stylesheetLoadTimeout,\r\n                    keepIframeSrcFn,\r\n                });\r\n                if (serializedIframeNode) {\r\n                    onIframeLoad(n, serializedIframeNode);\r\n                }\r\n            }\r\n        }, iframeLoadTimeout);\r\n    }\r\n    if (serializedNode.type === NodeType.Element &&\r\n        serializedNode.tagName === 'link' &&\r\n        serializedNode.attributes.rel === 'stylesheet') {\r\n        onceStylesheetLoaded(n, () => {\r\n            if (onStylesheetLoad) {\r\n                const serializedLinkNode = serializeNodeWithId(n, {\r\n                    doc,\r\n                    mirror,\r\n                    blockClass,\r\n                    blockSelector,\r\n                    unblockSelector,\r\n                    maskAllText,\r\n                    maskTextClass,\r\n                    unmaskTextClass,\r\n                    maskTextSelector,\r\n                    unmaskTextSelector,\r\n                    skipChild: false,\r\n                    inlineStylesheet,\r\n                    maskInputOptions,\r\n                    maskAttributeFn,\r\n                    maskTextFn,\r\n                    maskInputFn,\r\n                    slimDOMOptions,\r\n                    dataURLOptions,\r\n                    inlineImages,\r\n                    recordCanvas,\r\n                    preserveWhiteSpace,\r\n                    onSerialize,\r\n                    onIframeLoad,\r\n                    iframeLoadTimeout,\r\n                    onStylesheetLoad,\r\n                    stylesheetLoadTimeout,\r\n                    keepIframeSrcFn,\r\n                });\r\n                if (serializedLinkNode) {\r\n                    onStylesheetLoad(n, serializedLinkNode);\r\n                }\r\n            }\r\n        }, stylesheetLoadTimeout);\r\n    }\r\n    return serializedNode;\r\n}\r\nfunction snapshot(n, options) {\r\n    const { mirror = new Mirror(), blockClass = 'rr-block', blockSelector = null, unblockSelector = null, maskAllText = false, maskTextClass = 'rr-mask', unmaskTextClass = null, maskTextSelector = null, unmaskTextSelector = null, inlineStylesheet = true, inlineImages = false, recordCanvas = false, maskAllInputs = false, maskAttributeFn, maskTextFn, maskInputFn, slimDOM = false, dataURLOptions, preserveWhiteSpace, onSerialize, onIframeLoad, iframeLoadTimeout, onStylesheetLoad, stylesheetLoadTimeout, keepIframeSrcFn = () => false, } = options || {};\r\n    const maskInputOptions = maskAllInputs === true\r\n        ? {\r\n            color: true,\r\n            date: true,\r\n            'datetime-local': true,\r\n            email: true,\r\n            month: true,\r\n            number: true,\r\n            range: true,\r\n            search: true,\r\n            tel: true,\r\n            text: true,\r\n            time: true,\r\n            url: true,\r\n            week: true,\r\n            textarea: true,\r\n            select: true,\r\n        }\r\n        : maskAllInputs === false\r\n            ? {}\r\n            : maskAllInputs;\r\n    const slimDOMOptions = slimDOM === true || slimDOM === 'all'\r\n        ?\r\n            {\r\n                script: true,\r\n                comment: true,\r\n                headFavicon: true,\r\n                headWhitespace: true,\r\n                headMetaDescKeywords: slimDOM === 'all',\r\n                headMetaSocial: true,\r\n                headMetaRobots: true,\r\n                headMetaHttpEquiv: true,\r\n                headMetaAuthorship: true,\r\n                headMetaVerification: true,\r\n            }\r\n        : slimDOM === false\r\n            ? {}\r\n            : slimDOM;\r\n    return serializeNodeWithId(n, {\r\n        doc: n,\r\n        mirror,\r\n        blockClass,\r\n        blockSelector,\r\n        unblockSelector,\r\n        maskAllText,\r\n        maskTextClass,\r\n        unmaskTextClass,\r\n        maskTextSelector,\r\n        unmaskTextSelector,\r\n        skipChild: false,\r\n        inlineStylesheet,\r\n        maskInputOptions,\r\n        maskAttributeFn,\r\n        maskTextFn,\r\n        maskInputFn,\r\n        slimDOMOptions,\r\n        dataURLOptions,\r\n        inlineImages,\r\n        recordCanvas,\r\n        preserveWhiteSpace,\r\n        onSerialize,\r\n        onIframeLoad,\r\n        iframeLoadTimeout,\r\n        onStylesheetLoad,\r\n        stylesheetLoadTimeout,\r\n        keepIframeSrcFn,\r\n        newlyAddedElement: false,\r\n    });\r\n}\r\nfunction visitSnapshot(node, onVisit) {\r\n    function walk(current) {\r\n        onVisit(current);\r\n        if (current.type === NodeType.Document ||\r\n            current.type === NodeType.Element) {\r\n            current.childNodes.forEach(walk);\r\n        }\r\n    }\r\n    walk(node);\r\n}\r\nfunction cleanupSnapshot() {\r\n    _id = 1;\r\n}\n\nconst commentre = /\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\//g;\r\nfunction parse(css, options = {}) {\r\n    let lineno = 1;\r\n    let column = 1;\r\n    function updatePosition(str) {\r\n        const lines = str.match(/\\n/g);\r\n        if (lines) {\r\n            lineno += lines.length;\r\n        }\r\n        const i = str.lastIndexOf('\\n');\r\n        column = i === -1 ? column + str.length : str.length - i;\r\n    }\r\n    function position() {\r\n        const start = { line: lineno, column };\r\n        return (node) => {\r\n            node.position = new Position(start);\r\n            whitespace();\r\n            return node;\r\n        };\r\n    }\r\n    class Position {\r\n        constructor(start) {\r\n            this.start = start;\r\n            this.end = { line: lineno, column };\r\n            this.source = options.source;\r\n        }\r\n    }\r\n    Position.prototype.content = css;\r\n    const errorsList = [];\r\n    function error(msg) {\r\n        const err = new Error(`${options.source || ''}:${lineno}:${column}: ${msg}`);\r\n        err.reason = msg;\r\n        err.filename = options.source;\r\n        err.line = lineno;\r\n        err.column = column;\r\n        err.source = css;\r\n        if (options.silent) {\r\n            errorsList.push(err);\r\n        }\r\n        else {\r\n            throw err;\r\n        }\r\n    }\r\n    function stylesheet() {\r\n        const rulesList = rules();\r\n        return {\r\n            type: 'stylesheet',\r\n            stylesheet: {\r\n                source: options.source,\r\n                rules: rulesList,\r\n                parsingErrors: errorsList,\r\n            },\r\n        };\r\n    }\r\n    function open() {\r\n        return match(/^{\\s*/);\r\n    }\r\n    function close() {\r\n        return match(/^}/);\r\n    }\r\n    function rules() {\r\n        let node;\r\n        const rules = [];\r\n        whitespace();\r\n        comments(rules);\r\n        while (css.length && css.charAt(0) !== '}' && (node = atrule() || rule())) {\r\n            if (node) {\r\n                rules.push(node);\r\n                comments(rules);\r\n            }\r\n        }\r\n        return rules;\r\n    }\r\n    function match(re) {\r\n        const m = re.exec(css);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        const str = m[0];\r\n        updatePosition(str);\r\n        css = css.slice(str.length);\r\n        return m;\r\n    }\r\n    function whitespace() {\r\n        match(/^\\s*/);\r\n    }\r\n    function comments(rules = []) {\r\n        let c;\r\n        while ((c = comment())) {\r\n            if (c) {\r\n                rules.push(c);\r\n            }\r\n            c = comment();\r\n        }\r\n        return rules;\r\n    }\r\n    function comment() {\r\n        const pos = position();\r\n        if ('/' !== css.charAt(0) || '*' !== css.charAt(1)) {\r\n            return;\r\n        }\r\n        let i = 2;\r\n        while ('' !== css.charAt(i) &&\r\n            ('*' !== css.charAt(i) || '/' !== css.charAt(i + 1))) {\r\n            ++i;\r\n        }\r\n        i += 2;\r\n        if ('' === css.charAt(i - 1)) {\r\n            return error('End of comment missing');\r\n        }\r\n        const str = css.slice(2, i - 2);\r\n        column += 2;\r\n        updatePosition(str);\r\n        css = css.slice(i);\r\n        column += 2;\r\n        return pos({\r\n            type: 'comment',\r\n            comment: str,\r\n        });\r\n    }\r\n    function selector() {\r\n        whitespace();\r\n        while (css[0] == '}') {\r\n            error('extra closing bracket');\r\n            css = css.slice(1);\r\n            whitespace();\r\n        }\r\n        const m = match(/^((\"(?:\\\\\"|[^\"])*\"|'(?:\\\\'|[^'])*'|[^{])+)/);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        const cleanedInput = m[0]\r\n            .trim()\r\n            .replace(/\\/\\*([^*]|[\\r\\n]|(\\*+([^*/]|[\\r\\n])))*\\*\\/+/g, '')\r\n            .replace(/\"(?:\\\\\"|[^\"])*\"|'(?:\\\\'|[^'])*'/g, (m) => {\r\n            return m.replace(/,/g, '\\u200C');\r\n        });\r\n        return customSplit(cleanedInput).map((s) => s.replace(/\\u200C/g, ',').trim());\r\n    }\r\n    function customSplit(input) {\r\n        const result = [];\r\n        let currentSegment = '';\r\n        let depthParentheses = 0;\r\n        let depthBrackets = 0;\r\n        let currentStringChar = null;\r\n        for (const char of input) {\r\n            const hasStringEscape = currentSegment.endsWith('\\\\');\r\n            if (currentStringChar) {\r\n                if (currentStringChar === char && !hasStringEscape) {\r\n                    currentStringChar = null;\r\n                }\r\n            }\r\n            else if (char === '(') {\r\n                depthParentheses++;\r\n            }\r\n            else if (char === ')') {\r\n                depthParentheses--;\r\n            }\r\n            else if (char === '[') {\r\n                depthBrackets++;\r\n            }\r\n            else if (char === ']') {\r\n                depthBrackets--;\r\n            }\r\n            else if ('\\'\"'.includes(char)) {\r\n                currentStringChar = char;\r\n            }\r\n            if (char === ',' && depthParentheses === 0 && depthBrackets === 0) {\r\n                result.push(currentSegment);\r\n                currentSegment = '';\r\n            }\r\n            else {\r\n                currentSegment += char;\r\n            }\r\n        }\r\n        if (currentSegment) {\r\n            result.push(currentSegment);\r\n        }\r\n        return result;\r\n    }\r\n    function declaration() {\r\n        const pos = position();\r\n        const propMatch = match(/^(\\*?[-#\\/\\*\\\\\\w]+(\\[[0-9a-z_-]+\\])?)\\s*/);\r\n        if (!propMatch) {\r\n            return;\r\n        }\r\n        const prop = trim(propMatch[0]);\r\n        if (!match(/^:\\s*/)) {\r\n            return error(`property missing ':'`);\r\n        }\r\n        const val = match(/^((?:'(?:\\\\'|.)*?'|\"(?:\\\\\"|.)*?\"|\\([^\\)]*?\\)|[^};])+)/);\r\n        const ret = pos({\r\n            type: 'declaration',\r\n            property: prop.replace(commentre, ''),\r\n            value: val ? trim(val[0]).replace(commentre, '') : '',\r\n        });\r\n        match(/^[;\\s]*/);\r\n        return ret;\r\n    }\r\n    function declarations() {\r\n        const decls = [];\r\n        if (!open()) {\r\n            return error(`missing '{'`);\r\n        }\r\n        comments(decls);\r\n        let decl;\r\n        while ((decl = declaration())) {\r\n            if (decl !== false) {\r\n                decls.push(decl);\r\n                comments(decls);\r\n            }\r\n            decl = declaration();\r\n        }\r\n        if (!close()) {\r\n            return error(`missing '}'`);\r\n        }\r\n        return decls;\r\n    }\r\n    function keyframe() {\r\n        let m;\r\n        const vals = [];\r\n        const pos = position();\r\n        while ((m = match(/^((\\d+\\.\\d+|\\.\\d+|\\d+)%?|[a-z]+)\\s*/))) {\r\n            vals.push(m[1]);\r\n            match(/^,\\s*/);\r\n        }\r\n        if (!vals.length) {\r\n            return;\r\n        }\r\n        return pos({\r\n            type: 'keyframe',\r\n            values: vals,\r\n            declarations: declarations(),\r\n        });\r\n    }\r\n    function atkeyframes() {\r\n        const pos = position();\r\n        let m = match(/^@([-\\w]+)?keyframes\\s*/);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        const vendor = m[1];\r\n        m = match(/^([-\\w]+)\\s*/);\r\n        if (!m) {\r\n            return error('@keyframes missing name');\r\n        }\r\n        const name = m[1];\r\n        if (!open()) {\r\n            return error(`@keyframes missing '{'`);\r\n        }\r\n        let frame;\r\n        let frames = comments();\r\n        while ((frame = keyframe())) {\r\n            frames.push(frame);\r\n            frames = frames.concat(comments());\r\n        }\r\n        if (!close()) {\r\n            return error(`@keyframes missing '}'`);\r\n        }\r\n        return pos({\r\n            type: 'keyframes',\r\n            name,\r\n            vendor,\r\n            keyframes: frames,\r\n        });\r\n    }\r\n    function atsupports() {\r\n        const pos = position();\r\n        const m = match(/^@supports *([^{]+)/);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        const supports = trim(m[1]);\r\n        if (!open()) {\r\n            return error(`@supports missing '{'`);\r\n        }\r\n        const style = comments().concat(rules());\r\n        if (!close()) {\r\n            return error(`@supports missing '}'`);\r\n        }\r\n        return pos({\r\n            type: 'supports',\r\n            supports,\r\n            rules: style,\r\n        });\r\n    }\r\n    function athost() {\r\n        const pos = position();\r\n        const m = match(/^@host\\s*/);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        if (!open()) {\r\n            return error(`@host missing '{'`);\r\n        }\r\n        const style = comments().concat(rules());\r\n        if (!close()) {\r\n            return error(`@host missing '}'`);\r\n        }\r\n        return pos({\r\n            type: 'host',\r\n            rules: style,\r\n        });\r\n    }\r\n    function atmedia() {\r\n        const pos = position();\r\n        const m = match(/^@media *([^{]+)/);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        const media = trim(m[1]);\r\n        if (!open()) {\r\n            return error(`@media missing '{'`);\r\n        }\r\n        const style = comments().concat(rules());\r\n        if (!close()) {\r\n            return error(`@media missing '}'`);\r\n        }\r\n        return pos({\r\n            type: 'media',\r\n            media,\r\n            rules: style,\r\n        });\r\n    }\r\n    function atcustommedia() {\r\n        const pos = position();\r\n        const m = match(/^@custom-media\\s+(--[^\\s]+)\\s*([^{;]+);/);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        return pos({\r\n            type: 'custom-media',\r\n            name: trim(m[1]),\r\n            media: trim(m[2]),\r\n        });\r\n    }\r\n    function atpage() {\r\n        const pos = position();\r\n        const m = match(/^@page */);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        const sel = selector() || [];\r\n        if (!open()) {\r\n            return error(`@page missing '{'`);\r\n        }\r\n        let decls = comments();\r\n        let decl;\r\n        while ((decl = declaration())) {\r\n            decls.push(decl);\r\n            decls = decls.concat(comments());\r\n        }\r\n        if (!close()) {\r\n            return error(`@page missing '}'`);\r\n        }\r\n        return pos({\r\n            type: 'page',\r\n            selectors: sel,\r\n            declarations: decls,\r\n        });\r\n    }\r\n    function atdocument() {\r\n        const pos = position();\r\n        const m = match(/^@([-\\w]+)?document *([^{]+)/);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        const vendor = trim(m[1]);\r\n        const doc = trim(m[2]);\r\n        if (!open()) {\r\n            return error(`@document missing '{'`);\r\n        }\r\n        const style = comments().concat(rules());\r\n        if (!close()) {\r\n            return error(`@document missing '}'`);\r\n        }\r\n        return pos({\r\n            type: 'document',\r\n            document: doc,\r\n            vendor,\r\n            rules: style,\r\n        });\r\n    }\r\n    function atfontface() {\r\n        const pos = position();\r\n        const m = match(/^@font-face\\s*/);\r\n        if (!m) {\r\n            return;\r\n        }\r\n        if (!open()) {\r\n            return error(`@font-face missing '{'`);\r\n        }\r\n        let decls = comments();\r\n        let decl;\r\n        while ((decl = declaration())) {\r\n            decls.push(decl);\r\n            decls = decls.concat(comments());\r\n        }\r\n        if (!close()) {\r\n            return error(`@font-face missing '}'`);\r\n        }\r\n        return pos({\r\n            type: 'font-face',\r\n            declarations: decls,\r\n        });\r\n    }\r\n    const atimport = _compileAtrule('import');\r\n    const atcharset = _compileAtrule('charset');\r\n    const atnamespace = _compileAtrule('namespace');\r\n    function _compileAtrule(name) {\r\n        const re = new RegExp('^@' + name + '\\\\s*([^;]+);');\r\n        return () => {\r\n            const pos = position();\r\n            const m = match(re);\r\n            if (!m) {\r\n                return;\r\n            }\r\n            const ret = { type: name };\r\n            ret[name] = m[1].trim();\r\n            return pos(ret);\r\n        };\r\n    }\r\n    function atrule() {\r\n        if (css[0] !== '@') {\r\n            return;\r\n        }\r\n        return (atkeyframes() ||\r\n            atmedia() ||\r\n            atcustommedia() ||\r\n            atsupports() ||\r\n            atimport() ||\r\n            atcharset() ||\r\n            atnamespace() ||\r\n            atdocument() ||\r\n            atpage() ||\r\n            athost() ||\r\n            atfontface());\r\n    }\r\n    function rule() {\r\n        const pos = position();\r\n        const sel = selector();\r\n        if (!sel) {\r\n            return error('selector missing');\r\n        }\r\n        comments();\r\n        return pos({\r\n            type: 'rule',\r\n            selectors: sel,\r\n            declarations: declarations(),\r\n        });\r\n    }\r\n    return addParent(stylesheet());\r\n}\r\nfunction trim(str) {\r\n    return str ? str.replace(/^\\s+|\\s+$/g, '') : '';\r\n}\r\nfunction addParent(obj, parent) {\r\n    const isNode = obj && typeof obj.type === 'string';\r\n    const childParent = isNode ? obj : parent;\r\n    for (const k of Object.keys(obj)) {\r\n        const value = obj[k];\r\n        if (Array.isArray(value)) {\r\n            value.forEach((v) => {\r\n                addParent(v, childParent);\r\n            });\r\n        }\r\n        else if (value && typeof value === 'object') {\r\n            addParent(value, childParent);\r\n        }\r\n    }\r\n    if (isNode) {\r\n        Object.defineProperty(obj, 'parent', {\r\n            configurable: true,\r\n            writable: true,\r\n            enumerable: false,\r\n            value: parent || null,\r\n        });\r\n    }\r\n    return obj;\r\n}\n\nconst tagMap = {\r\n    script: 'noscript',\r\n    altglyph: 'altGlyph',\r\n    altglyphdef: 'altGlyphDef',\r\n    altglyphitem: 'altGlyphItem',\r\n    animatecolor: 'animateColor',\r\n    animatemotion: 'animateMotion',\r\n    animatetransform: 'animateTransform',\r\n    clippath: 'clipPath',\r\n    feblend: 'feBlend',\r\n    fecolormatrix: 'feColorMatrix',\r\n    fecomponenttransfer: 'feComponentTransfer',\r\n    fecomposite: 'feComposite',\r\n    feconvolvematrix: 'feConvolveMatrix',\r\n    fediffuselighting: 'feDiffuseLighting',\r\n    fedisplacementmap: 'feDisplacementMap',\r\n    fedistantlight: 'feDistantLight',\r\n    fedropshadow: 'feDropShadow',\r\n    feflood: 'feFlood',\r\n    fefunca: 'feFuncA',\r\n    fefuncb: 'feFuncB',\r\n    fefuncg: 'feFuncG',\r\n    fefuncr: 'feFuncR',\r\n    fegaussianblur: 'feGaussianBlur',\r\n    feimage: 'feImage',\r\n    femerge: 'feMerge',\r\n    femergenode: 'feMergeNode',\r\n    femorphology: 'feMorphology',\r\n    feoffset: 'feOffset',\r\n    fepointlight: 'fePointLight',\r\n    fespecularlighting: 'feSpecularLighting',\r\n    fespotlight: 'feSpotLight',\r\n    fetile: 'feTile',\r\n    feturbulence: 'feTurbulence',\r\n    foreignobject: 'foreignObject',\r\n    glyphref: 'glyphRef',\r\n    lineargradient: 'linearGradient',\r\n    radialgradient: 'radialGradient',\r\n};\r\nfunction getTagName(n) {\r\n    let tagName = tagMap[n.tagName] ? tagMap[n.tagName] : n.tagName;\r\n    if (tagName === 'link' && n.attributes._cssText) {\r\n        tagName = 'style';\r\n    }\r\n    return tagName;\r\n}\r\nfunction escapeRegExp(str) {\r\n    return str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\r\n}\r\nconst HOVER_SELECTOR = /([^\\\\]):hover/;\r\nconst HOVER_SELECTOR_GLOBAL = new RegExp(HOVER_SELECTOR.source, 'g');\r\nfunction addHoverClass(cssText, cache) {\r\n    const cachedStyle = cache?.stylesWithHoverClass.get(cssText);\r\n    if (cachedStyle)\r\n        return cachedStyle;\r\n    if (cssText.length >= 1000000) {\r\n        return cssText;\r\n    }\r\n    const ast = parse(cssText, {\r\n        silent: true,\r\n    });\r\n    if (!ast.stylesheet) {\r\n        return cssText;\r\n    }\r\n    const selectors = [];\r\n    ast.stylesheet.rules.forEach((rule) => {\r\n        if ('selectors' in rule) {\r\n            (rule.selectors || []).forEach((selector) => {\r\n                if (HOVER_SELECTOR.test(selector)) {\r\n                    selectors.push(selector);\r\n                }\r\n            });\r\n        }\r\n    });\r\n    if (selectors.length === 0) {\r\n        return cssText;\r\n    }\r\n    const selectorMatcher = new RegExp(selectors\r\n        .filter((selector, index) => selectors.indexOf(selector) === index)\r\n        .sort((a, b) => b.length - a.length)\r\n        .map((selector) => {\r\n        return escapeRegExp(selector);\r\n    })\r\n        .join('|'), 'g');\r\n    const result = cssText.replace(selectorMatcher, (selector) => {\r\n        const newSelector = selector.replace(HOVER_SELECTOR_GLOBAL, '$1.\\\\:hover');\r\n        return `${selector}, ${newSelector}`;\r\n    });\r\n    cache?.stylesWithHoverClass.set(cssText, result);\r\n    return result;\r\n}\r\nfunction createCache() {\r\n    const stylesWithHoverClass = new Map();\r\n    return {\r\n        stylesWithHoverClass,\r\n    };\r\n}\r\nfunction buildNode(n, options) {\r\n    const { doc, hackCss, cache } = options;\r\n    switch (n.type) {\r\n        case NodeType.Document:\r\n            return doc.implementation.createDocument(null, '', null);\r\n        case NodeType.DocumentType:\r\n            return doc.implementation.createDocumentType(n.name || 'html', n.publicId, n.systemId);\r\n        case NodeType.Element: {\r\n            const tagName = getTagName(n);\r\n            let node;\r\n            if (n.isSVG) {\r\n                node = doc.createElementNS('http://www.w3.org/2000/svg', tagName);\r\n            }\r\n            else {\r\n                if (n.isCustom &&\r\n                    doc.defaultView?.customElements &&\r\n                    !doc.defaultView.customElements.get(n.tagName))\r\n                    doc.defaultView.customElements.define(n.tagName, class extends doc.defaultView.HTMLElement {\r\n                    });\r\n                node = doc.createElement(tagName);\r\n            }\r\n            const specialAttributes = {};\r\n            for (const name in n.attributes) {\r\n                if (!Object.prototype.hasOwnProperty.call(n.attributes, name)) {\r\n                    continue;\r\n                }\r\n                let value = n.attributes[name];\r\n                if (tagName === 'option' &&\r\n                    name === 'selected' &&\r\n                    value === false) {\r\n                    continue;\r\n                }\r\n                if (value === null) {\r\n                    continue;\r\n                }\r\n                if (value === true)\r\n                    value = '';\r\n                if (name.startsWith('rr_')) {\r\n                    specialAttributes[name] = value;\r\n                    continue;\r\n                }\r\n                const isTextarea = tagName === 'textarea' && name === 'value';\r\n                const isRemoteOrDynamicCss = tagName === 'style' && name === '_cssText';\r\n                if (isRemoteOrDynamicCss && hackCss && typeof value === 'string') {\r\n                    value = addHoverClass(value, cache);\r\n                }\r\n                if ((isTextarea || isRemoteOrDynamicCss) && typeof value === 'string') {\r\n                    const child = doc.createTextNode(value);\r\n                    for (const c of Array.from(node.childNodes)) {\r\n                        if (c.nodeType === node.TEXT_NODE) {\r\n                            node.removeChild(c);\r\n                        }\r\n                    }\r\n                    node.appendChild(child);\r\n                    continue;\r\n                }\r\n                try {\r\n                    if (n.isSVG && name === 'xlink:href') {\r\n                        node.setAttributeNS('http://www.w3.org/1999/xlink', name, value.toString());\r\n                    }\r\n                    else if (name === 'onload' ||\r\n                        name === 'onclick' ||\r\n                        name.substring(0, 7) === 'onmouse') {\r\n                        node.setAttribute('_' + name, value.toString());\r\n                    }\r\n                    else if (tagName === 'meta' &&\r\n                        n.attributes['http-equiv'] === 'Content-Security-Policy' &&\r\n                        name === 'content') {\r\n                        node.setAttribute('csp-content', value.toString());\r\n                        continue;\r\n                    }\r\n                    else if (tagName === 'link' &&\r\n                        (n.attributes.rel === 'preload' ||\r\n                            n.attributes.rel === 'modulepreload') &&\r\n                        n.attributes.as === 'script') {\r\n                    }\r\n                    else if (tagName === 'link' &&\r\n                        n.attributes.rel === 'prefetch' &&\r\n                        typeof n.attributes.href === 'string' &&\r\n                        n.attributes.href.endsWith('.js')) {\r\n                    }\r\n                    else if (tagName === 'img' &&\r\n                        n.attributes.srcset &&\r\n                        n.attributes.rr_dataURL) {\r\n                        node.setAttribute('rrweb-original-srcset', n.attributes.srcset);\r\n                    }\r\n                    else {\r\n                        node.setAttribute(name, value.toString());\r\n                    }\r\n                }\r\n                catch (error) {\r\n                }\r\n            }\r\n            for (const name in specialAttributes) {\r\n                const value = specialAttributes[name];\r\n                if (tagName === 'canvas' && name === 'rr_dataURL') {\r\n                    const image = document.createElement('img');\r\n                    image.onload = () => {\r\n                        const ctx = node.getContext('2d');\r\n                        if (ctx) {\r\n                            ctx.drawImage(image, 0, 0, image.width, image.height);\r\n                        }\r\n                    };\r\n                    image.src = value.toString();\r\n                    if (node.RRNodeType)\r\n                        node.rr_dataURL = value.toString();\r\n                }\r\n                else if (tagName === 'img' && name === 'rr_dataURL') {\r\n                    const image = node;\r\n                    if (!image.currentSrc.startsWith('data:')) {\r\n                        image.setAttribute('rrweb-original-src', n.attributes.src);\r\n                        image.src = value.toString();\r\n                    }\r\n                }\r\n                if (name === 'rr_width') {\r\n                    node.style.setProperty('width', value.toString());\r\n                }\r\n                else if (name === 'rr_height') {\r\n                    node.style.setProperty('height', value.toString());\r\n                }\r\n                else if (name === 'rr_mediaCurrentTime' &&\r\n                    typeof value === 'number') {\r\n                    node.currentTime = value;\r\n                }\r\n                else if (name === 'rr_mediaState') {\r\n                    switch (value) {\r\n                        case 'played':\r\n                            node\r\n                                .play()\r\n                                .catch((e) => console.warn('media playback error', e));\r\n                            break;\r\n                        case 'paused':\r\n                            node.pause();\r\n                            break;\r\n                    }\r\n                }\r\n            }\r\n            if (n.isShadowHost) {\r\n                if (!node.shadowRoot) {\r\n                    node.attachShadow({ mode: 'open' });\r\n                }\r\n                else {\r\n                    while (node.shadowRoot.firstChild) {\r\n                        node.shadowRoot.removeChild(node.shadowRoot.firstChild);\r\n                    }\r\n                }\r\n            }\r\n            return node;\r\n        }\r\n        case NodeType.Text:\r\n            return doc.createTextNode(n.isStyle && hackCss\r\n                ? addHoverClass(n.textContent, cache)\r\n                : n.textContent);\r\n        case NodeType.CDATA:\r\n            return doc.createCDATASection(n.textContent);\r\n        case NodeType.Comment:\r\n            return doc.createComment(n.textContent);\r\n        default:\r\n            return null;\r\n    }\r\n}\r\nfunction buildNodeWithSN(n, options) {\r\n    const { doc, mirror, skipChild = false, hackCss = true, afterAppend, cache, } = options;\r\n    if (mirror.has(n.id)) {\r\n        const nodeInMirror = mirror.getNode(n.id);\r\n        const meta = mirror.getMeta(nodeInMirror);\r\n        if (isNodeMetaEqual(meta, n))\r\n            return mirror.getNode(n.id);\r\n    }\r\n    let node = buildNode(n, { doc, hackCss, cache });\r\n    if (!node) {\r\n        return null;\r\n    }\r\n    if (n.rootId && mirror.getNode(n.rootId) !== doc) {\r\n        mirror.replace(n.rootId, doc);\r\n    }\r\n    if (n.type === NodeType.Document) {\r\n        doc.close();\r\n        doc.open();\r\n        if (n.compatMode === 'BackCompat' &&\r\n            n.childNodes &&\r\n            n.childNodes[0].type !== NodeType.DocumentType) {\r\n            if (n.childNodes[0].type === NodeType.Element &&\r\n                'xmlns' in n.childNodes[0].attributes &&\r\n                n.childNodes[0].attributes.xmlns === 'http://www.w3.org/1999/xhtml') {\r\n                doc.write('<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"\">');\r\n            }\r\n            else {\r\n                doc.write('<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\" \"\">');\r\n            }\r\n        }\r\n        node = doc;\r\n    }\r\n    mirror.add(node, n);\r\n    if ((n.type === NodeType.Document || n.type === NodeType.Element) &&\r\n        !skipChild) {\r\n        for (const childN of n.childNodes) {\r\n            const childNode = buildNodeWithSN(childN, {\r\n                doc,\r\n                mirror,\r\n                skipChild: false,\r\n                hackCss,\r\n                afterAppend,\r\n                cache,\r\n            });\r\n            if (!childNode) {\r\n                console.warn('Failed to rebuild', childN);\r\n                continue;\r\n            }\r\n            if (childN.isShadow && isElement(node) && node.shadowRoot) {\r\n                node.shadowRoot.appendChild(childNode);\r\n            }\r\n            else if (n.type === NodeType.Document &&\r\n                childN.type == NodeType.Element) {\r\n                const htmlElement = childNode;\r\n                let body = null;\r\n                htmlElement.childNodes.forEach((child) => {\r\n                    if (child.nodeName === 'BODY')\r\n                        body = child;\r\n                });\r\n                if (body) {\r\n                    htmlElement.removeChild(body);\r\n                    node.appendChild(childNode);\r\n                    htmlElement.appendChild(body);\r\n                }\r\n                else {\r\n                    node.appendChild(childNode);\r\n                }\r\n            }\r\n            else {\r\n                node.appendChild(childNode);\r\n            }\r\n            if (afterAppend) {\r\n                afterAppend(childNode, childN.id);\r\n            }\r\n        }\r\n    }\r\n    return node;\r\n}\r\nfunction visit(mirror, onVisit) {\r\n    function walk(node) {\r\n        onVisit(node);\r\n    }\r\n    for (const id of mirror.getIds()) {\r\n        if (mirror.has(id)) {\r\n            walk(mirror.getNode(id));\r\n        }\r\n    }\r\n}\r\nfunction handleScroll(node, mirror) {\r\n    const n = mirror.getMeta(node);\r\n    if (n?.type !== NodeType.Element) {\r\n        return;\r\n    }\r\n    const el = node;\r\n    for (const name in n.attributes) {\r\n        if (!(Object.prototype.hasOwnProperty.call(n.attributes, name) &&\r\n            name.startsWith('rr_'))) {\r\n            continue;\r\n        }\r\n        const value = n.attributes[name];\r\n        if (name === 'rr_scrollLeft') {\r\n            el.scrollLeft = value;\r\n        }\r\n        if (name === 'rr_scrollTop') {\r\n            el.scrollTop = value;\r\n        }\r\n    }\r\n}\r\nfunction rebuild(n, options) {\r\n    const { doc, onVisit, hackCss = true, afterAppend, cache, mirror = new Mirror(), } = options;\r\n    const node = buildNodeWithSN(n, {\r\n        doc,\r\n        mirror,\r\n        skipChild: false,\r\n        hackCss,\r\n        afterAppend,\r\n        cache,\r\n    });\r\n    visit(mirror, (visitedNode) => {\r\n        if (onVisit) {\r\n            onVisit(visitedNode);\r\n        }\r\n        handleScroll(visitedNode, mirror);\r\n    });\r\n    return node;\r\n}\n\nexport { IGNORED_NODE, Mirror, NodeType, addHoverClass, buildNodeWithSN, classMatchesRegex, cleanupSnapshot, createCache, createMatchPredicate, createMirror, distanceToMatch, escapeImportStatement, fixSafariColons, genId, getInputType, getInputValue, ignoreAttribute, is2DCanvasBlank, isCSSImportRule, isCSSStyleRule, isElement, isNativeShadowDom, isNodeMetaEqual, isShadowRoot, maskInputValue, needMaskingText, rebuild, serializeNodeWithId, shouldMaskInput, snapshot, stringifyRule, stringifyStylesheet, toLowerCase, toUpperCase, transformAttribute, visitSnapshot };\n","type ClassOption = string | RegExp;\n\n/** Duplicate this from @sentry-internal/rrweb so we can export this as well. */\nexport const ReplayEventTypeDomContentLoaded = 0;\nexport const ReplayEventTypeLoad = 1;\nexport const ReplayEventTypeFullSnapshot = 2;\nexport const ReplayEventTypeIncrementalSnapshot = 3;\nexport const ReplayEventTypeMeta = 4;\nexport const ReplayEventTypeCustom = 5;\nexport const ReplayEventTypePlugin = 6;\n\nexport type ReplayEventType =\n  | typeof ReplayEventTypeDomContentLoaded\n  | typeof ReplayEventTypeLoad\n  | typeof ReplayEventTypeFullSnapshot\n  | typeof ReplayEventTypeIncrementalSnapshot\n  | typeof ReplayEventTypeMeta\n  | typeof ReplayEventTypeCustom\n  | typeof ReplayEventTypePlugin;\n\n/**\n * This is a partial copy of rrweb's eventWithTime type which only contains the properties\n * we specifcally need in the SDK.\n */\nexport type ReplayEventWithTime = {\n  type: ReplayEventType;\n  data: unknown;\n  timestamp: number;\n  delay?: number;\n};\n\n/**\n * This is a partial copy of rrweb's recording options which only contains the properties\n * we specifically us in the SDK. Users can specify additional properties, hence we add the\n * Record<string, unknown> union type.\n */\nexport type RrwebRecordOptions = {\n  maskAllText?: boolean;\n  maskAllInputs?: boolean;\n  blockClass?: ClassOption;\n  ignoreClass?: string;\n  maskTextClass?: ClassOption;\n  maskTextSelector?: string;\n  blockSelector?: string;\n  maskInputOptions?: Record<string, boolean>;\n} & Record<string, unknown>;\n\nexport interface CanvasManagerInterface {\n  reset(): void;\n  freeze(): void;\n  unfreeze(): void;\n  lock(): void;\n  unlock(): void;\n  snapshot(): void;\n}\n\nexport interface CanvasManagerOptions {\n  recordCanvas: boolean;\n  enableManualSnapshot?: boolean;\n  blockClass: string | RegExp;\n  blockSelector: string | null;\n  unblockSelector: string | null;\n  sampling?: 'all' | number;\n  dataURLOptions: Partial<{\n    type: string;\n    quality: number;\n  }>;\n  mutationCb: (p: any) => void;\n  win: typeof globalThis & Window;\n  mirror: any;\n}\n","import type { ReplayBreadcrumbFrame } from '../types/replayFrame';\n\n/**\n * Create a breadcrumb for a replay.\n */\nexport function createBreadcrumb(\n  breadcrumb: Omit<ReplayBreadcrumbFrame, 'timestamp' | 'type'> & Partial<Pick<ReplayBreadcrumbFrame, 'timestamp'>>,\n): ReplayBreadcrumbFrame {\n  return {\n    timestamp: Date.now() / 1000,\n    type: 'default',\n    ...breadcrumb,\n  };\n}\n","// Note that these are the serialized attributes and not attributes directly on\n// the DOM Node. Attributes we are interested in:\nconst ATTRIBUTES_TO_RECORD = new Set([\n  'id',\n  'class',\n  'aria-label',\n  'role',\n  'name',\n  'alt',\n  'title',\n  'data-test-id',\n  'data-testid',\n  'disabled',\n  'aria-disabled',\n  'data-sentry-component',\n]);\n\n/**\n * Inclusion list of attributes that we want to record from the DOM element\n */\nexport function getAttributesToRecord(attributes: Record<string, unknown>): Record<string, unknown> {\n  const obj: Record<string, unknown> = {};\n  for (const key in attributes) {\n    if (ATTRIBUTES_TO_RECORD.has(key)) {\n      let normalizedKey = key;\n\n      if (key === 'data-testid' || key === 'data-test-id') {\n        normalizedKey = 'testId';\n      }\n\n      obj[normalizedKey] = attributes[key];\n    }\n  }\n\n  return obj;\n}\n","import { record } from '@sentry-internal/rrweb';\nimport type { serializedElementNodeWithId, serializedNodeWithId } from '@sentry-internal/rrweb-snapshot';\nimport { NodeType } from '@sentry-internal/rrweb-snapshot';\nimport type { Breadcrumb, HandlerDataDom } from '@sentry/types';\nimport { htmlTreeAsString } from '@sentry/utils';\n\nimport type { ReplayContainer } from '../types';\nimport { createBreadcrumb } from '../util/createBreadcrumb';\nimport { handleClick } from './handleClick';\nimport { addBreadcrumbEvent } from './util/addBreadcrumbEvent';\nimport { getClickTargetNode, getTargetNode } from './util/domUtils';\nimport { getAttributesToRecord } from './util/getAttributesToRecord';\n\nexport const handleDomListener: (replay: ReplayContainer) => (handlerData: HandlerDataDom) => void = (\n  replay: ReplayContainer,\n) => {\n  return (handlerData: HandlerDataDom): void => {\n    if (!replay.isEnabled()) {\n      return;\n    }\n\n    const result = handleDom(handlerData);\n\n    if (!result) {\n      return;\n    }\n\n    const isClick = handlerData.name === 'click';\n    const event = isClick ? (handlerData.event as PointerEvent) : undefined;\n    // Ignore clicks if ctrl/alt/meta/shift keys are held down as they alter behavior of clicks (e.g. open in new tab)\n    if (\n      isClick &&\n      replay.clickDetector &&\n      event &&\n      event.target &&\n      !event.altKey &&\n      !event.metaKey &&\n      !event.ctrlKey &&\n      !event.shiftKey\n    ) {\n      handleClick(\n        replay.clickDetector,\n        result as Breadcrumb & { timestamp: number; data: { nodeId: number } },\n        getClickTargetNode(handlerData.event as Event) as HTMLElement,\n      );\n    }\n\n    addBreadcrumbEvent(replay, result);\n  };\n};\n\n/** Get the base DOM breadcrumb. */\nexport function getBaseDomBreadcrumb(target: Node | null, message: string): Breadcrumb {\n  const nodeId = record.mirror.getId(target);\n  const node = nodeId && record.mirror.getNode(nodeId);\n  const meta = node && record.mirror.getMeta(node);\n  const element = meta && isElement(meta) ? meta : null;\n\n  return {\n    message,\n    data: element\n      ? {\n          nodeId,\n          node: {\n            id: nodeId,\n            tagName: element.tagName,\n            textContent: Array.from(element.childNodes)\n              .map((node: serializedNodeWithId) => node.type === NodeType.Text && node.textContent)\n              .filter(Boolean) // filter out empty values\n              .map(text => (text as string).trim())\n              .join(''),\n            attributes: getAttributesToRecord(element.attributes),\n          },\n        }\n      : {},\n  };\n}\n\n/**\n * An event handler to react to DOM events.\n * Exported for tests.\n */\nexport function handleDom(handlerData: HandlerDataDom): Breadcrumb | null {\n  const { target, message } = getDomTarget(handlerData);\n\n  return createBreadcrumb({\n    category: `ui.${handlerData.name}`,\n    ...getBaseDomBreadcrumb(target, message),\n  });\n}\n\nfunction getDomTarget(handlerData: HandlerDataDom): { target: Node | null; message: string } {\n  const isClick = handlerData.name === 'click';\n\n  let message: string | undefined;\n  let target: Node | null = null;\n\n  // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n  try {\n    target = isClick ? getClickTargetNode(handlerData.event as Event) : getTargetNode(handlerData.event as Event);\n    message = htmlTreeAsString(target, { maxStringLength: 200 }) || '<unknown>';\n  } catch (e) {\n    message = '<unknown>';\n  }\n\n  return { target, message };\n}\n\nfunction isElement(node: serializedNodeWithId): node is serializedElementNodeWithId {\n  return node.type === NodeType.Element;\n}\n","import type { Breadcrumb } from '@sentry/types';\nimport { htmlTreeAsString } from '@sentry/utils';\n\nimport type { ReplayContainer } from '../types';\nimport { createBreadcrumb } from '../util/createBreadcrumb';\nimport { getBaseDomBreadcrumb } from './handleDom';\nimport { addBreadcrumbEvent } from './util/addBreadcrumbEvent';\n\n/** Handle keyboard events & create breadcrumbs. */\nexport function handleKeyboardEvent(replay: ReplayContainer, event: KeyboardEvent): void {\n  if (!replay.isEnabled()) {\n    return;\n  }\n\n  // Update user activity, but do not restart recording as it can create\n  // noisy/low-value replays (e.g. user comes back from idle, hits alt-tab, new\n  // session with a single \"keydown\" breadcrumb is created)\n  replay.updateUserActivity();\n\n  const breadcrumb = getKeyboardBreadcrumb(event);\n\n  if (!breadcrumb) {\n    return;\n  }\n\n  addBreadcrumbEvent(replay, breadcrumb);\n}\n\n/** exported only for tests */\nexport function getKeyboardBreadcrumb(event: KeyboardEvent): Breadcrumb | null {\n  const { metaKey, shiftKey, ctrlKey, altKey, key, target } = event;\n\n  // never capture for input fields\n  if (!target || isInputElement(target as HTMLElement) || !key) {\n    return null;\n  }\n\n  // Note: We do not consider shift here, as that means \"uppercase\"\n  const hasModifierKey = metaKey || ctrlKey || altKey;\n  const isCharacterKey = key.length === 1; // other keys like Escape, Tab, etc have a longer length\n\n  // Do not capture breadcrumb if only a word key is pressed\n  // This could leak e.g. user input\n  if (!hasModifierKey && isCharacterKey) {\n    return null;\n  }\n\n  const message = htmlTreeAsString(target, { maxStringLength: 200 }) || '<unknown>';\n  const baseBreadcrumb = getBaseDomBreadcrumb(target as Node, message);\n\n  return createBreadcrumb({\n    category: 'ui.keyDown',\n    message,\n    data: {\n      ...baseBreadcrumb.data,\n      metaKey,\n      shiftKey,\n      ctrlKey,\n      altKey,\n      key,\n    },\n  });\n}\n\nfunction isInputElement(target: HTMLElement): boolean {\n  return target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable;\n}\n","import { record } from '@sentry-internal/rrweb';\nimport { browserPerformanceTimeOrigin } from '@sentry/utils';\n\nimport { WINDOW } from '../constants';\nimport type {\n  AllPerformanceEntry,\n  AllPerformanceEntryData,\n  ExperimentalPerformanceResourceTiming,\n  LargestContentfulPaintData,\n  NavigationData,\n  PaintData,\n  ReplayPerformanceEntry,\n  ResourceData,\n} from '../types';\n\n// Map entryType -> function to normalize data for event\nconst ENTRY_TYPES: Record<\n  string,\n  (entry: AllPerformanceEntry) => null | ReplayPerformanceEntry<AllPerformanceEntryData>\n> = {\n  // @ts-expect-error TODO: entry type does not fit the create* functions entry type\n  resource: createResourceEntry,\n  paint: createPaintEntry,\n  // @ts-expect-error TODO: entry type does not fit the create* functions entry type\n  navigation: createNavigationEntry,\n};\n\n/**\n * Create replay performance entries from the browser performance entries.\n */\nexport function createPerformanceEntries(\n  entries: AllPerformanceEntry[],\n): ReplayPerformanceEntry<AllPerformanceEntryData>[] {\n  return entries.map(createPerformanceEntry).filter(Boolean) as ReplayPerformanceEntry<AllPerformanceEntryData>[];\n}\n\nfunction createPerformanceEntry(entry: AllPerformanceEntry): ReplayPerformanceEntry<AllPerformanceEntryData> | null {\n  if (!ENTRY_TYPES[entry.entryType]) {\n    return null;\n  }\n\n  return ENTRY_TYPES[entry.entryType](entry);\n}\n\nfunction getAbsoluteTime(time: number): number {\n  // browserPerformanceTimeOrigin can be undefined if `performance` or\n  // `performance.now` doesn't exist, but this is already checked by this integration\n  return ((browserPerformanceTimeOrigin || WINDOW.performance.timeOrigin) + time) / 1000;\n}\n\nfunction createPaintEntry(entry: PerformancePaintTiming): ReplayPerformanceEntry<PaintData> {\n  const { duration, entryType, name, startTime } = entry;\n\n  const start = getAbsoluteTime(startTime);\n  return {\n    type: entryType,\n    name,\n    start,\n    end: start + duration,\n    data: undefined,\n  };\n}\n\nfunction createNavigationEntry(entry: PerformanceNavigationTiming): ReplayPerformanceEntry<NavigationData> | null {\n  const {\n    entryType,\n    name,\n    decodedBodySize,\n    duration,\n    domComplete,\n    encodedBodySize,\n    domContentLoadedEventStart,\n    domContentLoadedEventEnd,\n    domInteractive,\n    loadEventStart,\n    loadEventEnd,\n    redirectCount,\n    startTime,\n    transferSize,\n    type,\n  } = entry;\n\n  // Ignore entries with no duration, they do not seem to be useful and cause dupes\n  if (duration === 0) {\n    return null;\n  }\n\n  return {\n    type: `${entryType}.${type}`,\n    start: getAbsoluteTime(startTime),\n    end: getAbsoluteTime(domComplete),\n    name,\n    data: {\n      size: transferSize,\n      decodedBodySize,\n      encodedBodySize,\n      duration,\n      domInteractive,\n      domContentLoadedEventStart,\n      domContentLoadedEventEnd,\n      loadEventStart,\n      loadEventEnd,\n      domComplete,\n      redirectCount,\n    },\n  };\n}\n\nfunction createResourceEntry(\n  entry: ExperimentalPerformanceResourceTiming,\n): ReplayPerformanceEntry<ResourceData> | null {\n  const {\n    entryType,\n    initiatorType,\n    name,\n    responseEnd,\n    startTime,\n    decodedBodySize,\n    encodedBodySize,\n    responseStatus,\n    transferSize,\n  } = entry;\n\n  // Core SDK handles these\n  if (['fetch', 'xmlhttprequest'].includes(initiatorType)) {\n    return null;\n  }\n\n  return {\n    type: `${entryType}.${initiatorType}`,\n    start: getAbsoluteTime(startTime),\n    end: getAbsoluteTime(responseEnd),\n    name,\n    data: {\n      size: transferSize,\n      statusCode: responseStatus,\n      decodedBodySize,\n      encodedBodySize,\n    },\n  };\n}\n\n/**\n * Add a LCP event to the replay based on an LCP metric.\n */\nexport function getLargestContentfulPaint(metric: {\n  value: number;\n  entries: PerformanceEntry[];\n}): ReplayPerformanceEntry<LargestContentfulPaintData> {\n  const entries = metric.entries;\n  const lastEntry = entries[entries.length - 1] as (PerformanceEntry & { element?: Element }) | undefined;\n  const element = lastEntry ? lastEntry.element : undefined;\n\n  const value = metric.value;\n\n  const end = getAbsoluteTime(value);\n\n  const data: ReplayPerformanceEntry<LargestContentfulPaintData> = {\n    type: 'largest-contentful-paint',\n    name: 'largest-contentful-paint',\n    start: end,\n    end,\n    data: {\n      value,\n      size: value,\n      nodeId: element ? record.mirror.getId(element) : undefined,\n    },\n  };\n\n  return data;\n}\n","import { addLcpInstrumentationHandler, addPerformanceInstrumentationHandler } from '@sentry-internal/tracing';\n\nimport type { ReplayContainer } from '../types';\nimport { getLargestContentfulPaint } from '../util/createPerformanceEntries';\n\n/**\n * Sets up a PerformanceObserver to listen to all performance entry types.\n * Returns a callback to stop observing.\n */\nexport function setupPerformanceObserver(replay: ReplayContainer): () => void {\n  function addPerformanceEntry(entry: PerformanceEntry): void {\n    // It is possible for entries to come up multiple times\n    if (!replay.performanceEntries.includes(entry)) {\n      replay.performanceEntries.push(entry);\n    }\n  }\n\n  function onEntries({ entries }: { entries: PerformanceEntry[] }): void {\n    entries.forEach(addPerformanceEntry);\n  }\n\n  const clearCallbacks: (() => void)[] = [];\n\n  (['navigation', 'paint', 'resource'] as const).forEach(type => {\n    clearCallbacks.push(addPerformanceInstrumentationHandler(type, onEntries));\n  });\n\n  clearCallbacks.push(\n    addLcpInstrumentationHandler(({ metric }) => {\n      replay.replayPerformanceEntries.push(getLargestContentfulPaint(metric));\n    }),\n  );\n\n  // A callback to cleanup all handlers\n  return () => {\n    clearCallbacks.forEach(clearCallback => clearCallback());\n  };\n}\n","import { addBreadcrumb } from '@sentry/core';\nimport { logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../debug-build';\n\n/**\n * Log a message in debug mode, and add a breadcrumb when _experiment.traceInternals is enabled.\n */\nexport function logInfo(message: string, shouldAddBreadcrumb?: boolean): void {\n  if (!DEBUG_BUILD) {\n    return;\n  }\n\n  logger.info(message);\n\n  if (shouldAddBreadcrumb) {\n    addLogBreadcrumb(message);\n  }\n}\n\n/**\n * Log a message, and add a breadcrumb in the next tick.\n * This is necessary when the breadcrumb may be added before the replay is initialized.\n */\nexport function logInfoNextTick(message: string, shouldAddBreadcrumb?: boolean): void {\n  if (!DEBUG_BUILD) {\n    return;\n  }\n\n  logger.info(message);\n\n  if (shouldAddBreadcrumb) {\n    // Wait a tick here to avoid race conditions for some initial logs\n    // which may be added before replay is initialized\n    setTimeout(() => {\n      addLogBreadcrumb(message);\n    }, 0);\n  }\n}\n\nfunction addLogBreadcrumb(message: string): void {\n  addBreadcrumb(\n    {\n      category: 'console',\n      data: {\n        logger: 'replay',\n      },\n      level: 'info',\n      message,\n    },\n    { level: 'info' },\n  );\n}\n","import { REPLAY_MAX_EVENT_BUFFER_SIZE } from '../constants';\n\n/** This error indicates that the event buffer size exceeded the limit.. */\nexport class EventBufferSizeExceededError extends Error {\n  public constructor() {\n    super(`Event buffer exceeded maximum size of ${REPLAY_MAX_EVENT_BUFFER_SIZE}.`);\n  }\n}\n","import { REPLAY_MAX_EVENT_BUFFER_SIZE } from '../constants';\nimport type { AddEventResult, EventBuffer, EventBufferType, RecordingEvent } from '../types';\nimport { timestampToMs } from '../util/timestamp';\nimport { EventBufferSizeExceededError } from './error';\n\n/**\n * A basic event buffer that does not do any compression.\n * Used as fallback if the compression worker cannot be loaded or is disabled.\n */\nexport class EventBufferArray implements EventBuffer {\n  /** All the events that are buffered to be sent. */\n  public events: RecordingEvent[];\n\n  /** @inheritdoc */\n  public hasCheckout: boolean;\n\n  private _totalSize: number;\n\n  public constructor() {\n    this.events = [];\n    this._totalSize = 0;\n    this.hasCheckout = false;\n  }\n\n  /** @inheritdoc */\n  public get hasEvents(): boolean {\n    return this.events.length > 0;\n  }\n\n  /** @inheritdoc */\n  public get type(): EventBufferType {\n    return 'sync';\n  }\n\n  /** @inheritdoc */\n  public destroy(): void {\n    this.events = [];\n  }\n\n  /** @inheritdoc */\n  public async addEvent(event: RecordingEvent): Promise<AddEventResult> {\n    const eventSize = JSON.stringify(event).length;\n    this._totalSize += eventSize;\n    if (this._totalSize > REPLAY_MAX_EVENT_BUFFER_SIZE) {\n      throw new EventBufferSizeExceededError();\n    }\n\n    this.events.push(event);\n  }\n\n  /** @inheritdoc */\n  public finish(): Promise<string> {\n    return new Promise<string>(resolve => {\n      // Make a copy of the events array reference and immediately clear the\n      // events member so that we do not lose new events while uploading\n      // attachment.\n      const eventsRet = this.events;\n      this.clear();\n      resolve(JSON.stringify(eventsRet));\n    });\n  }\n\n  /** @inheritdoc */\n  public clear(): void {\n    this.events = [];\n    this._totalSize = 0;\n    this.hasCheckout = false;\n  }\n\n  /** @inheritdoc */\n  public getEarliestTimestamp(): number | null {\n    const timestamp = this.events.map(event => event.timestamp).sort()[0];\n\n    if (!timestamp) {\n      return null;\n    }\n\n    return timestampToMs(timestamp);\n  }\n}\n","import { logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport type { WorkerRequest, WorkerResponse } from '../types';\nimport { logInfo } from '../util/log';\n\n/**\n * Event buffer that uses a web worker to compress events.\n * Exported only for testing.\n */\nexport class WorkerHandler {\n  private _worker: Worker;\n  private _id: number;\n  private _ensureReadyPromise?: Promise<void>;\n\n  public constructor(worker: Worker) {\n    this._worker = worker;\n    this._id = 0;\n  }\n\n  /**\n   * Ensure the worker is ready (or not).\n   * This will either resolve when the worker is ready, or reject if an error occured.\n   */\n  public ensureReady(): Promise<void> {\n    // Ensure we only check once\n    if (this._ensureReadyPromise) {\n      return this._ensureReadyPromise;\n    }\n\n    this._ensureReadyPromise = new Promise((resolve, reject) => {\n      this._worker.addEventListener(\n        'message',\n        ({ data }: MessageEvent) => {\n          if ((data as WorkerResponse).success) {\n            resolve();\n          } else {\n            reject();\n          }\n        },\n        { once: true },\n      );\n\n      this._worker.addEventListener(\n        'error',\n        error => {\n          reject(error);\n        },\n        { once: true },\n      );\n    });\n\n    return this._ensureReadyPromise;\n  }\n\n  /**\n   * Destroy the worker.\n   */\n  public destroy(): void {\n    logInfo('[Replay] Destroying compression worker');\n    this._worker.terminate();\n  }\n\n  /**\n   * Post message to worker and wait for response before resolving promise.\n   */\n  public postMessage<T>(method: WorkerRequest['method'], arg?: WorkerRequest['arg']): Promise<T> {\n    const id = this._getAndIncrementId();\n\n    return new Promise((resolve, reject) => {\n      const listener = ({ data }: MessageEvent): void => {\n        const response = data as WorkerResponse;\n        if (response.method !== method) {\n          return;\n        }\n\n        // There can be multiple listeners for a single method, the id ensures\n        // that the response matches the caller.\n        if (response.id !== id) {\n          return;\n        }\n\n        // At this point, we'll always want to remove listener regardless of result status\n        this._worker.removeEventListener('message', listener);\n\n        if (!response.success) {\n          // TODO: Do some error handling, not sure what\n          DEBUG_BUILD && logger.error('[Replay]', response.response);\n\n          reject(new Error('Error in compression worker'));\n          return;\n        }\n\n        resolve(response.response as T);\n      };\n\n      // Note: we can't use `once` option because it's possible it needs to\n      // listen to multiple messages\n      this._worker.addEventListener('message', listener);\n      this._worker.postMessage({ id, method, arg });\n    });\n  }\n\n  /** Get the current ID and increment it for the next call. */\n  private _getAndIncrementId(): number {\n    return this._id++;\n  }\n}\n","import type { ReplayRecordingData } from '@sentry/types';\n\nimport { logger } from '@sentry/utils';\nimport { REPLAY_MAX_EVENT_BUFFER_SIZE } from '../constants';\nimport { DEBUG_BUILD } from '../debug-build';\nimport type { AddEventResult, EventBuffer, EventBufferType, RecordingEvent } from '../types';\nimport { timestampToMs } from '../util/timestamp';\nimport { WorkerHandler } from './WorkerHandler';\nimport { EventBufferSizeExceededError } from './error';\n\n/**\n * Event buffer that uses a web worker to compress events.\n * Exported only for testing.\n */\nexport class EventBufferCompressionWorker implements EventBuffer {\n  /** @inheritdoc */\n  public hasCheckout: boolean;\n\n  private _worker: WorkerHandler;\n  private _earliestTimestamp: number | null;\n  private _totalSize;\n\n  public constructor(worker: Worker) {\n    this._worker = new WorkerHandler(worker);\n    this._earliestTimestamp = null;\n    this._totalSize = 0;\n    this.hasCheckout = false;\n  }\n\n  /** @inheritdoc */\n  public get hasEvents(): boolean {\n    return !!this._earliestTimestamp;\n  }\n\n  /** @inheritdoc */\n  public get type(): EventBufferType {\n    return 'worker';\n  }\n\n  /**\n   * Ensure the worker is ready (or not).\n   * This will either resolve when the worker is ready, or reject if an error occured.\n   */\n  public ensureReady(): Promise<void> {\n    return this._worker.ensureReady();\n  }\n\n  /**\n   * Destroy the event buffer.\n   */\n  public destroy(): void {\n    this._worker.destroy();\n  }\n\n  /**\n   * Add an event to the event buffer.\n   *\n   * Returns true if event was successfuly received and processed by worker.\n   */\n  public addEvent(event: RecordingEvent): Promise<AddEventResult> {\n    const timestamp = timestampToMs(event.timestamp);\n    if (!this._earliestTimestamp || timestamp < this._earliestTimestamp) {\n      this._earliestTimestamp = timestamp;\n    }\n\n    const data = JSON.stringify(event);\n    this._totalSize += data.length;\n\n    if (this._totalSize > REPLAY_MAX_EVENT_BUFFER_SIZE) {\n      return Promise.reject(new EventBufferSizeExceededError());\n    }\n\n    return this._sendEventToWorker(data);\n  }\n\n  /**\n   * Finish the event buffer and return the compressed data.\n   */\n  public finish(): Promise<ReplayRecordingData> {\n    return this._finishRequest();\n  }\n\n  /** @inheritdoc */\n  public clear(): void {\n    this._earliestTimestamp = null;\n    this._totalSize = 0;\n    this.hasCheckout = false;\n\n    // We do not wait on this, as we assume the order of messages is consistent for the worker\n    this._worker.postMessage('clear').then(null, e => {\n      DEBUG_BUILD && logger.warn('[Replay] Sending \"clear\" message to worker failed', e);\n    });\n  }\n\n  /** @inheritdoc */\n  public getEarliestTimestamp(): number | null {\n    return this._earliestTimestamp;\n  }\n\n  /**\n   * Send the event to the worker.\n   */\n  private _sendEventToWorker(data: string): Promise<AddEventResult> {\n    return this._worker.postMessage<void>('addEvent', data);\n  }\n\n  /**\n   * Finish the request and return the compressed data from the worker.\n   */\n  private async _finishRequest(): Promise<Uint8Array> {\n    const response = await this._worker.postMessage<Uint8Array>('finish');\n\n    this._earliestTimestamp = null;\n    this._totalSize = 0;\n\n    return response;\n  }\n}\n","import type { ReplayRecordingData } from '@sentry/types';\nimport { logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport type { AddEventResult, EventBuffer, EventBufferType, RecordingEvent } from '../types';\nimport { logInfo } from '../util/log';\nimport { EventBufferArray } from './EventBufferArray';\nimport { EventBufferCompressionWorker } from './EventBufferCompressionWorker';\n\n/**\n * This proxy will try to use the compression worker, and fall back to use the simple buffer if an error occurs there.\n * This can happen e.g. if the worker cannot be loaded.\n * Exported only for testing.\n */\nexport class EventBufferProxy implements EventBuffer {\n  private _fallback: EventBufferArray;\n  private _compression: EventBufferCompressionWorker;\n  private _used: EventBuffer;\n  private _ensureWorkerIsLoadedPromise: Promise<void>;\n\n  public constructor(worker: Worker) {\n    this._fallback = new EventBufferArray();\n    this._compression = new EventBufferCompressionWorker(worker);\n    this._used = this._fallback;\n\n    this._ensureWorkerIsLoadedPromise = this._ensureWorkerIsLoaded();\n  }\n\n  /** @inheritdoc */\n  public get type(): EventBufferType {\n    return this._used.type;\n  }\n\n  /** @inheritDoc */\n  public get hasEvents(): boolean {\n    return this._used.hasEvents;\n  }\n\n  /** @inheritdoc */\n  public get hasCheckout(): boolean {\n    return this._used.hasCheckout;\n  }\n  /** @inheritdoc */\n  public set hasCheckout(value: boolean) {\n    this._used.hasCheckout = value;\n  }\n\n  /** @inheritDoc */\n  public destroy(): void {\n    this._fallback.destroy();\n    this._compression.destroy();\n  }\n\n  /** @inheritdoc */\n  public clear(): void {\n    return this._used.clear();\n  }\n\n  /** @inheritdoc */\n  public getEarliestTimestamp(): number | null {\n    return this._used.getEarliestTimestamp();\n  }\n\n  /**\n   * Add an event to the event buffer.\n   *\n   * Returns true if event was successfully added.\n   */\n  public addEvent(event: RecordingEvent): Promise<AddEventResult> {\n    return this._used.addEvent(event);\n  }\n\n  /** @inheritDoc */\n  public async finish(): Promise<ReplayRecordingData> {\n    // Ensure the worker is loaded, so the sent event is compressed\n    await this.ensureWorkerIsLoaded();\n\n    return this._used.finish();\n  }\n\n  /** Ensure the worker has loaded. */\n  public ensureWorkerIsLoaded(): Promise<void> {\n    return this._ensureWorkerIsLoadedPromise;\n  }\n\n  /** Actually check if the worker has been loaded. */\n  private async _ensureWorkerIsLoaded(): Promise<void> {\n    try {\n      await this._compression.ensureReady();\n    } catch (error) {\n      // If the worker fails to load, we fall back to the simple buffer.\n      // Nothing more to do from our side here\n      logInfo('[Replay] Failed to load the compression worker, falling back to simple buffer');\n      return;\n    }\n\n    // Now we need to switch over the array buffer to the compression worker\n    await this._switchToCompressionWorker();\n  }\n\n  /** Switch the used buffer to the compression worker. */\n  private async _switchToCompressionWorker(): Promise<void> {\n    const { events, hasCheckout } = this._fallback;\n\n    const addEventPromises: Promise<void>[] = [];\n    for (const event of events) {\n      addEventPromises.push(this._compression.addEvent(event));\n    }\n\n    this._compression.hasCheckout = hasCheckout;\n\n    // We switch over to the new buffer immediately - any further events will be added\n    // after the previously buffered ones\n    this._used = this._compression;\n\n    // Wait for original events to be re-added before resolving\n    try {\n      await Promise.all(addEventPromises);\n    } catch (error) {\n      DEBUG_BUILD && logger.warn('[Replay] Failed to add events when switching buffers.', error);\n    }\n  }\n}\n","import { getWorkerURL } from '@sentry-internal/replay-worker';\n\nimport type { EventBuffer } from '../types';\nimport { logInfo } from '../util/log';\nimport { EventBufferArray } from './EventBufferArray';\nimport { EventBufferProxy } from './EventBufferProxy';\n\ninterface CreateEventBufferParams {\n  useCompression: boolean;\n  workerUrl?: string;\n}\n\n// Treeshakable guard to remove the code of the included compression worker\ndeclare const __SENTRY_EXCLUDE_REPLAY_WORKER__: boolean;\n\n/**\n * Create an event buffer for replays.\n */\nexport function createEventBuffer({\n  useCompression,\n  workerUrl: customWorkerUrl,\n}: CreateEventBufferParams): EventBuffer {\n  if (\n    useCompression &&\n    // eslint-disable-next-line no-restricted-globals\n    window.Worker\n  ) {\n    const worker = _loadWorker(customWorkerUrl);\n\n    if (worker) {\n      return worker;\n    }\n  }\n\n  logInfo('[Replay] Using simple buffer');\n  return new EventBufferArray();\n}\n\nfunction _loadWorker(customWorkerUrl?: string): EventBufferProxy | void {\n  try {\n    const workerUrl = customWorkerUrl || _getWorkerUrl();\n\n    if (!workerUrl) {\n      return;\n    }\n\n    logInfo(`[Replay] Using compression worker${customWorkerUrl ? ` from ${customWorkerUrl}` : ''}`);\n    const worker = new Worker(workerUrl);\n    return new EventBufferProxy(worker);\n  } catch (error) {\n    logInfo('[Replay] Failed to create compression worker');\n    // Fall back to use simple event buffer array\n  }\n}\n\nfunction _getWorkerUrl(): string {\n  if (typeof __SENTRY_EXCLUDE_REPLAY_WORKER__ === 'undefined' || !__SENTRY_EXCLUDE_REPLAY_WORKER__) {\n    return getWorkerURL();\n  }\n\n  return '';\n}\n","import r from\"./worker\";function e(){const e=new Blob([r]);return URL.createObjectURL(e)}export{e as getWorkerURL};\n","export default `var t=Uint8Array,n=Uint16Array,r=Int32Array,e=new t([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0,0]),i=new t([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,0,0]),a=new t([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),s=function(t,e){for(var i=new n(31),a=0;a<31;++a)i[a]=e+=1<<t[a-1];var s=new r(i[30]);for(a=1;a<30;++a)for(var o=i[a];o<i[a+1];++o)s[o]=o-i[a]<<5|a;return{b:i,r:s}},o=s(e,2),f=o.b,h=o.r;f[28]=258,h[258]=28;for(var l=s(i,0).r,u=new n(32768),c=0;c<32768;++c){var v=(43690&c)>>1|(21845&c)<<1;v=(61680&(v=(52428&v)>>2|(13107&v)<<2))>>4|(3855&v)<<4,u[c]=((65280&v)>>8|(255&v)<<8)>>1}var d=function(t,r,e){for(var i=t.length,a=0,s=new n(r);a<i;++a)t[a]&&++s[t[a]-1];var o,f=new n(r);for(a=1;a<r;++a)f[a]=f[a-1]+s[a-1]<<1;if(e){o=new n(1<<r);var h=15-r;for(a=0;a<i;++a)if(t[a])for(var l=a<<4|t[a],c=r-t[a],v=f[t[a]-1]++<<c,d=v|(1<<c)-1;v<=d;++v)o[u[v]>>h]=l}else for(o=new n(i),a=0;a<i;++a)t[a]&&(o[a]=u[f[t[a]-1]++]>>15-t[a]);return o},g=new t(288);for(c=0;c<144;++c)g[c]=8;for(c=144;c<256;++c)g[c]=9;for(c=256;c<280;++c)g[c]=7;for(c=280;c<288;++c)g[c]=8;var w=new t(32);for(c=0;c<32;++c)w[c]=5;var p=d(g,9,0),y=d(w,5,0),m=function(t){return(t+7)/8|0},b=function(n,r,e){return(null==r||r<0)&&(r=0),(null==e||e>n.length)&&(e=n.length),new t(n.subarray(r,e))},M=[\"unexpected EOF\",\"invalid block type\",\"invalid length/literal\",\"invalid distance\",\"stream finished\",\"no stream handler\",,\"no callback\",\"invalid UTF-8 data\",\"extra field too long\",\"date not in range 1980-2099\",\"filename too long\",\"stream finishing\",\"invalid zip data\"],E=function(t,n,r){var e=new Error(n||M[t]);if(e.code=t,Error.captureStackTrace&&Error.captureStackTrace(e,E),!r)throw e;return e},z=function(t,n,r){r<<=7&n;var e=n/8|0;t[e]|=r,t[e+1]|=r>>8},A=function(t,n,r){r<<=7&n;var e=n/8|0;t[e]|=r,t[e+1]|=r>>8,t[e+2]|=r>>16},_=function(r,e){for(var i=[],a=0;a<r.length;++a)r[a]&&i.push({s:a,f:r[a]});var s=i.length,o=i.slice();if(!s)return{t:F,l:0};if(1==s){var f=new t(i[0].s+1);return f[i[0].s]=1,{t:f,l:1}}i.sort((function(t,n){return t.f-n.f})),i.push({s:-1,f:25001});var h=i[0],l=i[1],u=0,c=1,v=2;for(i[0]={s:-1,f:h.f+l.f,l:h,r:l};c!=s-1;)h=i[i[u].f<i[v].f?u++:v++],l=i[u!=c&&i[u].f<i[v].f?u++:v++],i[c++]={s:-1,f:h.f+l.f,l:h,r:l};var d=o[0].s;for(a=1;a<s;++a)o[a].s>d&&(d=o[a].s);var g=new n(d+1),w=x(i[c-1],g,0);if(w>e){a=0;var p=0,y=w-e,m=1<<y;for(o.sort((function(t,n){return g[n.s]-g[t.s]||t.f-n.f}));a<s;++a){var b=o[a].s;if(!(g[b]>e))break;p+=m-(1<<w-g[b]),g[b]=e}for(p>>=y;p>0;){var M=o[a].s;g[M]<e?p-=1<<e-g[M]++-1:++a}for(;a>=0&&p;--a){var E=o[a].s;g[E]==e&&(--g[E],++p)}w=e}return{t:new t(g),l:w}},x=function(t,n,r){return-1==t.s?Math.max(x(t.l,n,r+1),x(t.r,n,r+1)):n[t.s]=r},D=function(t){for(var r=t.length;r&&!t[--r];);for(var e=new n(++r),i=0,a=t[0],s=1,o=function(t){e[i++]=t},f=1;f<=r;++f)if(t[f]==a&&f!=r)++s;else{if(!a&&s>2){for(;s>138;s-=138)o(32754);s>2&&(o(s>10?s-11<<5|28690:s-3<<5|12305),s=0)}else if(s>3){for(o(a),--s;s>6;s-=6)o(8304);s>2&&(o(s-3<<5|8208),s=0)}for(;s--;)o(a);s=1,a=t[f]}return{c:e.subarray(0,i),n:r}},T=function(t,n){for(var r=0,e=0;e<n.length;++e)r+=t[e]*n[e];return r},k=function(t,n,r){var e=r.length,i=m(n+2);t[i]=255&e,t[i+1]=e>>8,t[i+2]=255^t[i],t[i+3]=255^t[i+1];for(var a=0;a<e;++a)t[i+a+4]=r[a];return 8*(i+4+e)},C=function(t,r,s,o,f,h,l,u,c,v,m){z(r,m++,s),++f[256];for(var b=_(f,15),M=b.t,E=b.l,x=_(h,15),C=x.t,U=x.l,F=D(M),I=F.c,S=F.n,L=D(C),O=L.c,j=L.n,q=new n(19),B=0;B<I.length;++B)++q[31&I[B]];for(B=0;B<O.length;++B)++q[31&O[B]];for(var G=_(q,7),H=G.t,J=G.l,K=19;K>4&&!H[a[K-1]];--K);var N,P,Q,R,V=v+5<<3,W=T(f,g)+T(h,w)+l,X=T(f,M)+T(h,C)+l+14+3*K+T(q,H)+2*q[16]+3*q[17]+7*q[18];if(c>=0&&V<=W&&V<=X)return k(r,m,t.subarray(c,c+v));if(z(r,m,1+(X<W)),m+=2,X<W){N=d(M,E,0),P=M,Q=d(C,U,0),R=C;var Y=d(H,J,0);z(r,m,S-257),z(r,m+5,j-1),z(r,m+10,K-4),m+=14;for(B=0;B<K;++B)z(r,m+3*B,H[a[B]]);m+=3*K;for(var Z=[I,O],$=0;$<2;++$){var tt=Z[$];for(B=0;B<tt.length;++B){var nt=31&tt[B];z(r,m,Y[nt]),m+=H[nt],nt>15&&(z(r,m,tt[B]>>5&127),m+=tt[B]>>12)}}}else N=p,P=g,Q=y,R=w;for(B=0;B<u;++B){var rt=o[B];if(rt>255){A(r,m,N[(nt=rt>>18&31)+257]),m+=P[nt+257],nt>7&&(z(r,m,rt>>23&31),m+=e[nt]);var et=31&rt;A(r,m,Q[et]),m+=R[et],et>3&&(A(r,m,rt>>5&8191),m+=i[et])}else A(r,m,N[rt]),m+=P[rt]}return A(r,m,N[256]),m+P[256]},U=new r([65540,131080,131088,131104,262176,1048704,1048832,2114560,2117632]),F=new t(0),I=function(){for(var t=new Int32Array(256),n=0;n<256;++n){for(var r=n,e=9;--e;)r=(1&r&&-306674912)^r>>>1;t[n]=r}return t}(),S=function(){var t=1,n=0;return{p:function(r){for(var e=t,i=n,a=0|r.length,s=0;s!=a;){for(var o=Math.min(s+2655,a);s<o;++s)i+=e+=r[s];e=(65535&e)+15*(e>>16),i=(65535&i)+15*(i>>16)}t=e,n=i},d:function(){return(255&(t%=65521))<<24|(65280&t)<<8|(255&(n%=65521))<<8|n>>8}}},L=function(a,s,o,f,u){if(!u&&(u={l:1},s.dictionary)){var c=s.dictionary.subarray(-32768),v=new t(c.length+a.length);v.set(c),v.set(a,c.length),a=v,u.w=c.length}return function(a,s,o,f,u,c){var v=c.z||a.length,d=new t(f+v+5*(1+Math.ceil(v/7e3))+u),g=d.subarray(f,d.length-u),w=c.l,p=7&(c.r||0);if(s){p&&(g[0]=c.r>>3);for(var y=U[s-1],M=y>>13,E=8191&y,z=(1<<o)-1,A=c.p||new n(32768),_=c.h||new n(z+1),x=Math.ceil(o/3),D=2*x,T=function(t){return(a[t]^a[t+1]<<x^a[t+2]<<D)&z},F=new r(25e3),I=new n(288),S=new n(32),L=0,O=0,j=c.i||0,q=0,B=c.w||0,G=0;j+2<v;++j){var H=T(j),J=32767&j,K=_[H];if(A[J]=K,_[H]=J,B<=j){var N=v-j;if((L>7e3||q>24576)&&(N>423||!w)){p=C(a,g,0,F,I,S,O,q,G,j-G,p),q=L=O=0,G=j;for(var P=0;P<286;++P)I[P]=0;for(P=0;P<30;++P)S[P]=0}var Q=2,R=0,V=E,W=J-K&32767;if(N>2&&H==T(j-W))for(var X=Math.min(M,N)-1,Y=Math.min(32767,j),Z=Math.min(258,N);W<=Y&&--V&&J!=K;){if(a[j+Q]==a[j+Q-W]){for(var $=0;$<Z&&a[j+$]==a[j+$-W];++$);if($>Q){if(Q=$,R=W,$>X)break;var tt=Math.min(W,$-2),nt=0;for(P=0;P<tt;++P){var rt=j-W+P&32767,et=rt-A[rt]&32767;et>nt&&(nt=et,K=rt)}}}W+=(J=K)-(K=A[J])&32767}if(R){F[q++]=268435456|h[Q]<<18|l[R];var it=31&h[Q],at=31&l[R];O+=e[it]+i[at],++I[257+it],++S[at],B=j+Q,++L}else F[q++]=a[j],++I[a[j]]}}for(j=Math.max(j,B);j<v;++j)F[q++]=a[j],++I[a[j]];p=C(a,g,w,F,I,S,O,q,G,j-G,p),w||(c.r=7&p|g[p/8|0]<<3,p-=7,c.h=_,c.p=A,c.i=j,c.w=B)}else{for(j=c.w||0;j<v+w;j+=65535){var st=j+65535;st>=v&&(g[p/8|0]=w,st=v),p=k(g,p+1,a.subarray(j,st))}c.i=v}return b(d,0,f+m(p)+u)}(a,null==s.level?6:s.level,null==s.mem?Math.ceil(1.5*Math.max(8,Math.min(13,Math.log(a.length)))):12+s.mem,o,f,u)},O=function(t,n,r){for(;r;++n)t[n]=r,r>>>=8},j=function(){function n(n,r){if(\"function\"==typeof n&&(r=n,n={}),this.ondata=r,this.o=n||{},this.s={l:0,i:32768,w:32768,z:32768},this.b=new t(98304),this.o.dictionary){var e=this.o.dictionary.subarray(-32768);this.b.set(e,32768-e.length),this.s.i=32768-e.length}}return n.prototype.p=function(t,n){this.ondata(L(t,this.o,0,0,this.s),n)},n.prototype.push=function(n,r){this.ondata||E(5),this.s.l&&E(4);var e=n.length+this.s.z;if(e>this.b.length){if(e>2*this.b.length-32768){var i=new t(-32768&e);i.set(this.b.subarray(0,this.s.z)),this.b=i}var a=this.b.length-this.s.z;a&&(this.b.set(n.subarray(0,a),this.s.z),this.s.z=this.b.length,this.p(this.b,!1)),this.b.set(this.b.subarray(-32768)),this.b.set(n.subarray(a),32768),this.s.z=n.length-a+32768,this.s.i=32766,this.s.w=32768}else this.b.set(n,this.s.z),this.s.z+=n.length;this.s.l=1&r,(this.s.z>this.s.w+8191||r)&&(this.p(this.b,r||!1),this.s.w=this.s.i,this.s.i-=2)},n}();function q(t,n){n||(n={});var r=function(){var t=-1;return{p:function(n){for(var r=t,e=0;e<n.length;++e)r=I[255&r^n[e]]^r>>>8;t=r},d:function(){return~t}}}(),e=t.length;r.p(t);var i,a=L(t,n,10+((i=n).filename?i.filename.length+1:0),8),s=a.length;return function(t,n){var r=n.filename;if(t[0]=31,t[1]=139,t[2]=8,t[8]=n.level<2?4:9==n.level?2:0,t[9]=3,0!=n.mtime&&O(t,4,Math.floor(new Date(n.mtime||Date.now())/1e3)),r){t[3]=8;for(var e=0;e<=r.length;++e)t[e+10]=r.charCodeAt(e)}}(a,n),O(a,s-8,r.d()),O(a,s-4,e),a}var B=function(){function t(t,n){this.c=S(),this.v=1,j.call(this,t,n)}return t.prototype.push=function(t,n){this.c.p(t),j.prototype.push.call(this,t,n)},t.prototype.p=function(t,n){var r=L(t,this.o,this.v&&(this.o.dictionary?6:2),n&&4,this.s);this.v&&(function(t,n){var r=n.level,e=0==r?0:r<6?1:9==r?3:2;if(t[0]=120,t[1]=e<<6|(n.dictionary&&32),t[1]|=31-(t[0]<<8|t[1])%31,n.dictionary){var i=S();i.p(n.dictionary),O(t,2,i.d())}}(r,this.o),this.v=0),n&&O(r,r.length-4,this.c.d()),this.ondata(r,n)},t}(),G=\"undefined\"!=typeof TextEncoder&&new TextEncoder,H=\"undefined\"!=typeof TextDecoder&&new TextDecoder;try{H.decode(F,{stream:!0})}catch(t){}var J=function(){function t(t){this.ondata=t}return t.prototype.push=function(t,n){this.ondata||E(5),this.d&&E(4),this.ondata(K(t),this.d=n||!1)},t}();function K(n,r){if(r){for(var e=new t(n.length),i=0;i<n.length;++i)e[i]=n.charCodeAt(i);return e}if(G)return G.encode(n);var a=n.length,s=new t(n.length+(n.length>>1)),o=0,f=function(t){s[o++]=t};for(i=0;i<a;++i){if(o+5>s.length){var h=new t(o+8+(a-i<<1));h.set(s),s=h}var l=n.charCodeAt(i);l<128||r?f(l):l<2048?(f(192|l>>6),f(128|63&l)):l>55295&&l<57344?(f(240|(l=65536+(1047552&l)|1023&n.charCodeAt(++i))>>18),f(128|l>>12&63),f(128|l>>6&63),f(128|63&l)):(f(224|l>>12),f(128|l>>6&63),f(128|63&l))}return b(s,0,o)}const N=new class{constructor(){this._init()}clear(){this._init()}addEvent(t){if(!t)throw new Error(\"Adding invalid event\");const n=this._hasEvents?\",\":\"\";this.stream.push(n+t),this._hasEvents=!0}finish(){this.stream.push(\"]\",!0);const t=function(t){let n=0;for(let r=0,e=t.length;r<e;r++)n+=t[r].length;const r=new Uint8Array(n);for(let n=0,e=0,i=t.length;n<i;n++){const i=t[n];r.set(i,e),e+=i.length}return r}(this._deflatedData);return this._init(),t}_init(){this._hasEvents=!1,this._deflatedData=[],this.deflate=new B,this.deflate.ondata=(t,n)=>{this._deflatedData.push(t)},this.stream=new J(((t,n)=>{this.deflate.push(t,n)})),this.stream.push(\"[\")}},P={clear:()=>{N.clear()},addEvent:t=>N.addEvent(t),finish:()=>N.finish(),compress:t=>function(t){return q(K(t))}(t)};addEventListener(\"message\",(function(t){const n=t.data.method,r=t.data.id,e=t.data.arg;if(n in P&&\"function\"==typeof P[n])try{const t=P[n](e);postMessage({id:r,method:n,success:!0,response:t})}catch(t){postMessage({id:r,method:n,success:!1,response:t.message}),console.error(t)}})),postMessage({id:void 0,method:\"init\",success:!0,response:void 0});`;\n","import { WINDOW } from '../constants';\n\n/** If sessionStorage is available. */\nexport function hasSessionStorage(): boolean {\n  try {\n    // This can throw, e.g. when being accessed in a sandboxed iframe\n    return 'sessionStorage' in WINDOW && !!WINDOW.sessionStorage;\n  } catch {\n    return false;\n  }\n}\n","import { REPLAY_SESSION_KEY, WINDOW } from '../../src/constants';\nimport type { ReplayContainer } from '../../src/types';\nimport { hasSessionStorage } from '../util/hasSessionStorage';\n\n/**\n * Removes the session from Session Storage and unsets session in replay instance\n */\nexport function clearSession(replay: ReplayContainer): void {\n  deleteSession();\n  replay.session = undefined;\n}\n\n/**\n * Deletes a session from storage\n */\nfunction deleteSession(): void {\n  if (!hasSessionStorage()) {\n    return;\n  }\n\n  try {\n    WINDOW.sessionStorage.removeItem(REPLAY_SESSION_KEY);\n  } catch {\n    // Ignore potential SecurityError exceptions\n  }\n}\n","/**\n * Given a sample rate, returns true if replay should be sampled.\n *\n * 1.0 = 100% sampling\n * 0.0 = 0% sampling\n */\nexport function isSampled(sampleRate?: number): boolean {\n  if (sampleRate === undefined) {\n    return false;\n  }\n\n  // Math.random() returns a number in range of 0 to 1 (inclusive of 0, but not 1)\n  return Math.random() < sampleRate;\n}\n","import { uuid4 } from '@sentry/utils';\n\nimport type { Sampled, Session } from '../types';\n\n/**\n * Get a session with defaults & applied sampling.\n */\nexport function makeSession(session: Partial<Session> & { sampled: Sampled }): Session {\n  const now = Date.now();\n  const id = session.id || uuid4();\n  // Note that this means we cannot set a started/lastActivity of `0`, but this should not be relevant outside of tests.\n  const started = session.started || now;\n  const lastActivity = session.lastActivity || now;\n  const segmentId = session.segmentId || 0;\n  const sampled = session.sampled;\n  const previousSessionId = session.previousSessionId;\n\n  return {\n    id,\n    started,\n    lastActivity,\n    segmentId,\n    sampled,\n    previousSessionId,\n  };\n}\n","import { REPLAY_SESSION_KEY, WINDOW } from '../constants';\nimport type { Session } from '../types';\nimport { hasSessionStorage } from '../util/hasSessionStorage';\n\n/**\n * Save a session to session storage.\n */\nexport function saveSession(session: Session): void {\n  if (!hasSessionStorage()) {\n    return;\n  }\n\n  try {\n    WINDOW.sessionStorage.setItem(REPLAY_SESSION_KEY, JSON.stringify(session));\n  } catch {\n    // Ignore potential SecurityError exceptions\n  }\n}\n","import type { Sampled, Session, SessionOptions } from '../types';\nimport { isSampled } from '../util/isSampled';\nimport { makeSession } from './Session';\nimport { saveSession } from './saveSession';\n\n/**\n * Get the sampled status for a session based on sample rates & current sampled status.\n */\nexport function getSessionSampleType(sessionSampleRate: number, allowBuffering: boolean): Sampled {\n  return isSampled(sessionSampleRate) ? 'session' : allowBuffering ? 'buffer' : false;\n}\n\n/**\n * Create a new session, which in its current implementation is a Sentry event\n * that all replays will be saved to as attachments. Currently, we only expect\n * one of these Sentry events per \"replay session\".\n */\nexport function createSession(\n  { sessionSampleRate, allowBuffering, stickySession = false }: SessionOptions,\n  { previousSessionId }: { previousSessionId?: string } = {},\n): Session {\n  const sampled = getSessionSampleType(sessionSampleRate, allowBuffering);\n  const session = makeSession({\n    sampled,\n    previousSessionId,\n  });\n\n  if (stickySession) {\n    saveSession(session);\n  }\n\n  return session;\n}\n","/**\n * Given an initial timestamp and an expiry duration, checks to see if current\n * time should be considered as expired.\n */\nexport function isExpired(\n  initialTime: null | number,\n  expiry: undefined | number,\n  targetTime: number = +new Date(),\n): boolean {\n  // Always expired if < 0\n  if (initialTime === null || expiry === undefined || expiry < 0) {\n    return true;\n  }\n\n  // Never expires if == 0\n  if (expiry === 0) {\n    return false;\n  }\n\n  return initialTime + expiry <= targetTime;\n}\n","import type { Session } from '../types';\nimport { isExpired } from './isExpired';\n\n/**\n * Checks to see if session is expired\n */\nexport function isSessionExpired(\n  session: Session,\n  {\n    maxReplayDuration,\n    sessionIdleExpire,\n    targetTime = Date.now(),\n  }: { maxReplayDuration: number; sessionIdleExpire: number; targetTime?: number },\n): boolean {\n  return (\n    // First, check that maximum session length has not been exceeded\n    isExpired(session.started, maxReplayDuration, targetTime) ||\n    // check that the idle timeout has not been exceeded (i.e. user has\n    // performed an action within the last `sessionIdleExpire` ms)\n    isExpired(session.lastActivity, sessionIdleExpire, targetTime)\n  );\n}\n","import type { Session } from '../types';\nimport { isSessionExpired } from '../util/isSessionExpired';\n\n/** If the session should be refreshed or not. */\nexport function shouldRefreshSession(\n  session: Session,\n  { sessionIdleExpire, maxReplayDuration }: { sessionIdleExpire: number; maxReplayDuration: number },\n): boolean {\n  // If not expired, all good, just keep the session\n  if (!isSessionExpired(session, { sessionIdleExpire, maxReplayDuration })) {\n    return false;\n  }\n\n  // If we are buffering & haven't ever flushed yet, always continue\n  if (session.sampled === 'buffer' && session.segmentId === 0) {\n    return false;\n  }\n\n  return true;\n}\n","import type { Session, SessionOptions } from '../types';\nimport { logInfoNextTick } from '../util/log';\nimport { createSession } from './createSession';\nimport { fetchSession } from './fetchSession';\nimport { shouldRefreshSession } from './shouldRefreshSession';\n\n/**\n * Get or create a session, when initializing the replay.\n * Returns a session that may be unsampled.\n */\nexport function loadOrCreateSession(\n  {\n    traceInternals,\n    sessionIdleExpire,\n    maxReplayDuration,\n    previousSessionId,\n  }: {\n    sessionIdleExpire: number;\n    maxReplayDuration: number;\n    traceInternals?: boolean;\n    previousSessionId?: string;\n  },\n  sessionOptions: SessionOptions,\n): Session {\n  const existingSession = sessionOptions.stickySession && fetchSession(traceInternals);\n\n  // No session exists yet, just create a new one\n  if (!existingSession) {\n    logInfoNextTick('[Replay] Creating new session', traceInternals);\n    return createSession(sessionOptions, { previousSessionId });\n  }\n\n  if (!shouldRefreshSession(existingSession, { sessionIdleExpire, maxReplayDuration })) {\n    return existingSession;\n  }\n\n  logInfoNextTick('[Replay] Session in sessionStorage is expired, creating new one...');\n  return createSession(sessionOptions, { previousSessionId: existingSession.id });\n}\n","import { REPLAY_SESSION_KEY, WINDOW } from '../constants';\nimport type { Session } from '../types';\nimport { hasSessionStorage } from '../util/hasSessionStorage';\nimport { logInfoNextTick } from '../util/log';\nimport { makeSession } from './Session';\n\n/**\n * Fetches a session from storage\n */\nexport function fetchSession(traceInternals?: boolean): Session | null {\n  if (!hasSessionStorage()) {\n    return null;\n  }\n\n  try {\n    // This can throw if cookies are disabled\n    const sessionStringFromStorage = WINDOW.sessionStorage.getItem(REPLAY_SESSION_KEY);\n\n    if (!sessionStringFromStorage) {\n      return null;\n    }\n\n    const sessionObj = JSON.parse(sessionStringFromStorage) as Session;\n\n    logInfoNextTick('[Replay] Loading existing session', traceInternals);\n\n    return makeSession(sessionObj);\n  } catch {\n    return null;\n  }\n}\n","import { EventType } from '@sentry-internal/rrweb';\nimport { getClient } from '@sentry/core';\nimport { logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport { EventBufferSizeExceededError } from '../eventBuffer/error';\nimport type { AddEventResult, RecordingEvent, ReplayContainer, ReplayFrameEvent, ReplayPluginOptions } from '../types';\nimport { logInfo } from './log';\nimport { timestampToMs } from './timestamp';\n\nfunction isCustomEvent(event: RecordingEvent): event is ReplayFrameEvent {\n  return event.type === EventType.Custom;\n}\n\n/**\n * Add an event to the event buffer.\n * In contrast to `addEvent`, this does not return a promise & does not wait for the adding of the event to succeed/fail.\n * Instead this returns `true` if we tried to add the event, else false.\n * It returns `false` e.g. if we are paused, disabled, or out of the max replay duration.\n *\n * `isCheckout` is true if this is either the very first event, or an event triggered by `checkoutEveryNms`.\n */\nexport function addEventSync(replay: ReplayContainer, event: RecordingEvent, isCheckout?: boolean): boolean {\n  if (!shouldAddEvent(replay, event)) {\n    return false;\n  }\n\n  // This should never reject\n  // eslint-disable-next-line @typescript-eslint/no-floating-promises\n  _addEvent(replay, event, isCheckout);\n\n  return true;\n}\n\n/**\n * Add an event to the event buffer.\n * Resolves to `null` if no event was added, else to `void`.\n *\n * `isCheckout` is true if this is either the very first event, or an event triggered by `checkoutEveryNms`.\n */\nexport function addEvent(\n  replay: ReplayContainer,\n  event: RecordingEvent,\n  isCheckout?: boolean,\n): Promise<AddEventResult | null> {\n  if (!shouldAddEvent(replay, event)) {\n    return Promise.resolve(null);\n  }\n\n  return _addEvent(replay, event, isCheckout);\n}\n\nasync function _addEvent(\n  replay: ReplayContainer,\n  event: RecordingEvent,\n  isCheckout?: boolean,\n): Promise<AddEventResult | null> {\n  if (!replay.eventBuffer) {\n    return null;\n  }\n\n  try {\n    if (isCheckout && replay.recordingMode === 'buffer') {\n      replay.eventBuffer.clear();\n    }\n\n    if (isCheckout) {\n      replay.eventBuffer.hasCheckout = true;\n    }\n\n    const replayOptions = replay.getOptions();\n\n    const eventAfterPossibleCallback = maybeApplyCallback(event, replayOptions.beforeAddRecordingEvent);\n\n    if (!eventAfterPossibleCallback) {\n      return;\n    }\n\n    return await replay.eventBuffer.addEvent(eventAfterPossibleCallback);\n  } catch (error) {\n    const reason = error && error instanceof EventBufferSizeExceededError ? 'addEventSizeExceeded' : 'addEvent';\n\n    DEBUG_BUILD && logger.error(error);\n    await replay.stop({ reason });\n\n    const client = getClient();\n\n    if (client) {\n      client.recordDroppedEvent('internal_sdk_error', 'replay');\n    }\n  }\n}\n\n/** Exported only for tests. */\nexport function shouldAddEvent(replay: ReplayContainer, event: RecordingEvent): boolean {\n  if (!replay.eventBuffer || replay.isPaused() || !replay.isEnabled()) {\n    return false;\n  }\n\n  const timestampInMs = timestampToMs(event.timestamp);\n\n  // Throw out events that happen more than 5 minutes ago. This can happen if\n  // page has been left open and idle for a long period of time and user\n  // comes back to trigger a new session. The performance entries rely on\n  // `performance.timeOrigin`, which is when the page first opened.\n  if (timestampInMs + replay.timeouts.sessionIdlePause < Date.now()) {\n    return false;\n  }\n\n  // Throw out events that are +60min from the initial timestamp\n  if (timestampInMs > replay.getContext().initialTimestamp + replay.getOptions().maxReplayDuration) {\n    logInfo(\n      `[Replay] Skipping event with timestamp ${timestampInMs} because it is after maxReplayDuration`,\n      replay.getOptions()._experiments.traceInternals,\n    );\n    return false;\n  }\n\n  return true;\n}\n\nfunction maybeApplyCallback(\n  event: RecordingEvent,\n  callback: ReplayPluginOptions['beforeAddRecordingEvent'],\n): RecordingEvent | null | undefined {\n  try {\n    if (typeof callback === 'function' && isCustomEvent(event)) {\n      return callback(event);\n    }\n  } catch (error) {\n    DEBUG_BUILD &&\n      logger.error('[Replay] An error occured in the `beforeAddRecordingEvent` callback, skipping the event...', error);\n    return null;\n  }\n\n  return event;\n}\n","import type { ErrorEvent, Event, FeedbackEvent, ReplayEvent, TransactionEvent } from '@sentry/types';\n\n/** If the event is an error event */\nexport function isErrorEvent(event: Event): event is ErrorEvent {\n  return !event.type;\n}\n\n/** If the event is a transaction event */\nexport function isTransactionEvent(event: Event): event is TransactionEvent {\n  return event.type === 'transaction';\n}\n\n/** If the event is an replay event */\nexport function isReplayEvent(event: Event): event is ReplayEvent {\n  return event.type === 'replay_event';\n}\n\n/** If the event is a feedback event */\nexport function isFeedbackEvent(event: Event): event is FeedbackEvent {\n  return event.type === 'feedback';\n}\n","import { getClient } from '@sentry/core';\nimport type { ErrorEvent, Event, TransactionEvent, Transport, TransportMakeRequestResponse } from '@sentry/types';\n\nimport type { ReplayContainer } from '../types';\nimport { isErrorEvent, isTransactionEvent } from '../util/eventUtils';\n\ntype AfterSendEventCallback = (event: Event, sendResponse: TransportMakeRequestResponse | void) => void;\n\n/**\n * Returns a listener to be added to `client.on('afterSendErrorEvent, listener)`.\n */\nexport function handleAfterSendEvent(replay: ReplayContainer): AfterSendEventCallback {\n  // Custom transports may still be returning `Promise<void>`, which means we cannot expect the status code to be available there\n  // TODO (v8): remove this check as it will no longer be necessary\n  const enforceStatusCode = isBaseTransportSend();\n\n  return (event: Event, sendResponse: TransportMakeRequestResponse | void) => {\n    if (!replay.isEnabled() || (!isErrorEvent(event) && !isTransactionEvent(event))) {\n      return;\n    }\n\n    const statusCode = sendResponse && sendResponse.statusCode;\n\n    // We only want to do stuff on successful error sending, otherwise you get error replays without errors attached\n    // If not using the base transport, we allow `undefined` response (as a custom transport may not implement this correctly yet)\n    // If we do use the base transport, we skip if we encountered an non-OK status code\n    if (enforceStatusCode && (!statusCode || statusCode < 200 || statusCode >= 300)) {\n      return;\n    }\n\n    if (isTransactionEvent(event)) {\n      handleTransactionEvent(replay, event);\n      return;\n    }\n\n    handleErrorEvent(replay, event);\n  };\n}\n\nfunction handleTransactionEvent(replay: ReplayContainer, event: TransactionEvent): void {\n  const replayContext = replay.getContext();\n\n  // Collect traceIds in _context regardless of `recordingMode`\n  // In error mode, _context gets cleared on every checkout\n  // We limit to max. 100 transactions linked\n  if (event.contexts && event.contexts.trace && event.contexts.trace.trace_id && replayContext.traceIds.size < 100) {\n    replayContext.traceIds.add(event.contexts.trace.trace_id as string);\n  }\n}\n\nfunction handleErrorEvent(replay: ReplayContainer, event: ErrorEvent): void {\n  const replayContext = replay.getContext();\n\n  // Add error to list of errorIds of replay. This is ok to do even if not\n  // sampled because context will get reset at next checkout.\n  // XXX: There is also a race condition where it's possible to capture an\n  // error to Sentry before Replay SDK has loaded, but response returns after\n  // it was loaded, and this gets called.\n  // We limit to max. 100 errors linked\n  if (event.event_id && replayContext.errorIds.size < 100) {\n    replayContext.errorIds.add(event.event_id);\n  }\n\n  // If error event is tagged with replay id it means it was sampled (when in buffer mode)\n  // Need to be very careful that this does not cause an infinite loop\n  if (replay.recordingMode !== 'buffer' || !event.tags || !event.tags.replayId) {\n    return;\n  }\n\n  const { beforeErrorSampling } = replay.getOptions();\n  if (typeof beforeErrorSampling === 'function' && !beforeErrorSampling(event)) {\n    return;\n  }\n\n  setTimeout(() => {\n    // Capture current event buffer as new replay\n    // This should never reject\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    replay.sendBufferedReplayOrFlush();\n  });\n}\n\nfunction isBaseTransportSend(): boolean {\n  const client = getClient();\n  if (!client) {\n    return false;\n  }\n\n  const transport = client.getTransport();\n  if (!transport) {\n    return false;\n  }\n\n  return (\n    (transport.send as Transport['send'] & { __sentry__baseTransport__?: true }).__sentry__baseTransport__ || false\n  );\n}\n","import type { ErrorEvent, Event } from '@sentry/types';\n\nimport type { ReplayContainer } from '../types';\nimport { createBreadcrumb } from '../util/createBreadcrumb';\nimport { isErrorEvent } from '../util/eventUtils';\nimport { addBreadcrumbEvent } from './util/addBreadcrumbEvent';\n\ntype BeforeSendEventCallback = (event: Event) => void;\n\n/**\n * Returns a listener to be added to `client.on('afterSendErrorEvent, listener)`.\n */\nexport function handleBeforeSendEvent(replay: ReplayContainer): BeforeSendEventCallback {\n  return (event: Event) => {\n    if (!replay.isEnabled() || !isErrorEvent(event)) {\n      return;\n    }\n\n    handleHydrationError(replay, event);\n  };\n}\n\nfunction handleHydrationError(replay: ReplayContainer, event: ErrorEvent): void {\n  const exceptionValue = event.exception && event.exception.values && event.exception.values[0].value;\n  if (typeof exceptionValue !== 'string') {\n    return;\n  }\n\n  if (\n    // Only matches errors in production builds of react-dom\n    // Example https://reactjs.org/docs/error-decoder.html?invariant=423\n    exceptionValue.match(/reactjs\\.org\\/docs\\/error-decoder\\.html\\?invariant=(418|419|422|423|425)/) ||\n    // Development builds of react-dom\n    // Error 1: Hydration failed because the initial UI does not match what was rendered on the server.\n    // Error 2: Text content does not match server-rendered HTML. Warning: Text content did not match.\n    exceptionValue.match(/(does not match server-rendered HTML|Hydration failed because)/i)\n  ) {\n    const breadcrumb = createBreadcrumb({\n      category: 'replay.hydrate-error',\n    });\n    addBreadcrumbEvent(replay, breadcrumb);\n  }\n}\n","import type { Event, EventHint } from '@sentry/types';\nimport { logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport type { ReplayContainer } from '../types';\nimport { isErrorEvent, isFeedbackEvent, isReplayEvent, isTransactionEvent } from '../util/eventUtils';\nimport { isRrwebError } from '../util/isRrwebError';\nimport { handleAfterSendEvent } from './handleAfterSendEvent';\nimport { addFeedbackBreadcrumb } from './util/addFeedbackBreadcrumb';\nimport { shouldSampleForBufferEvent } from './util/shouldSampleForBufferEvent';\n\n/**\n * Returns a listener to be added to `addEventProcessor(listener)`.\n */\nexport function handleGlobalEventListener(\n  replay: ReplayContainer,\n  includeAfterSendEventHandling = false,\n): (event: Event, hint: EventHint) => Event | null {\n  const afterSendHandler = includeAfterSendEventHandling ? handleAfterSendEvent(replay) : undefined;\n\n  return Object.assign(\n    (event: Event, hint: EventHint) => {\n      // Do nothing if replay has been disabled\n      if (!replay.isEnabled()) {\n        return event;\n      }\n\n      if (isReplayEvent(event)) {\n        // Replays have separate set of breadcrumbs, do not include breadcrumbs\n        // from core SDK\n        delete event.breadcrumbs;\n        return event;\n      }\n\n      // We only want to handle errors, transactions, and feedbacks, nothing else\n      if (!isErrorEvent(event) && !isTransactionEvent(event) && !isFeedbackEvent(event)) {\n        return event;\n      }\n\n      // Ensure we do not add replay_id if the session is expired\n      const isSessionActive = replay.checkAndHandleExpiredSession();\n      if (!isSessionActive) {\n        return event;\n      }\n\n      if (isFeedbackEvent(event)) {\n        // This should never reject\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        replay.flush();\n        event.contexts.feedback.replay_id = replay.getSessionId();\n        // Add a replay breadcrumb for this piece of feedback\n        addFeedbackBreadcrumb(replay, event);\n        return event;\n      }\n\n      // Unless `captureExceptions` is enabled, we want to ignore errors coming from rrweb\n      // As there can be a bunch of stuff going wrong in internals there, that we don't want to bubble up to users\n      if (isRrwebError(event, hint) && !replay.getOptions()._experiments.captureExceptions) {\n        DEBUG_BUILD && logger.log('[Replay] Ignoring error from rrweb internals', event);\n        return null;\n      }\n\n      // When in buffer mode, we decide to sample here.\n      // Later, in `handleAfterSendEvent`, if the replayId is set, we know that we sampled\n      // And convert the buffer session to a full session\n      const isErrorEventSampled = shouldSampleForBufferEvent(replay, event);\n\n      // Tag errors if it has been sampled in buffer mode, or if it is session mode\n      // Only tag transactions if in session mode\n      const shouldTagReplayId = isErrorEventSampled || replay.recordingMode === 'session';\n\n      if (shouldTagReplayId) {\n        event.tags = { ...event.tags, replayId: replay.getSessionId() };\n      }\n\n      // In cases where a custom client is used that does not support the new hooks (yet),\n      // we manually call this hook method here\n      if (afterSendHandler) {\n        // Pretend the error had a 200 response so we always capture it\n        afterSendHandler(event, { statusCode: 200 });\n      }\n\n      return event;\n    },\n    { id: 'Replay' },\n  );\n}\n","import { EventType } from '@sentry-internal/rrweb';\nimport type { FeedbackEvent } from '@sentry/types';\n\nimport type { ReplayBreadcrumbFrameEvent, ReplayContainer } from '../../types';\n\n/**\n * Add a feedback breadcrumb event to replay.\n */\nexport function addFeedbackBreadcrumb(replay: ReplayContainer, event: FeedbackEvent): void {\n  replay.triggerUserActivity();\n  replay.addUpdate(() => {\n    if (!event.timestamp) {\n      // Ignore events that don't have timestamps (this shouldn't happen, more of a typing issue)\n      // Return true here so that we don't flush\n      return true;\n    }\n\n    // This should never reject\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    replay.throttledAddEvent({\n      type: EventType.Custom,\n      timestamp: event.timestamp * 1000,\n      data: {\n        tag: 'breadcrumb',\n        payload: {\n          timestamp: event.timestamp,\n          type: 'default',\n          category: 'sentry.feedback',\n          data: {\n            feedbackId: event.event_id,\n          },\n        },\n      },\n    } as ReplayBreadcrumbFrameEvent);\n\n    return false;\n  });\n}\n","import type { Event, EventHint } from '@sentry/types';\n\n/**\n * Returns true if we think the given event is an error originating inside of rrweb.\n */\nexport function isRrwebError(event: Event, hint: EventHint): boolean {\n  if (event.type || !event.exception || !event.exception.values || !event.exception.values.length) {\n    return false;\n  }\n\n  // @ts-expect-error this may be set by rrweb when it finds errors\n  if (hint.originalException && hint.originalException.__rrweb__) {\n    return true;\n  }\n\n  return false;\n}\n","import type { Event } from '@sentry/types';\n\nimport { UNABLE_TO_SEND_REPLAY } from '../../constants';\nimport type { ReplayContainer } from '../../types';\nimport { isSampled } from '../../util/isSampled';\n\n/**\n * Determine if event should be sampled (only applies in buffer mode).\n * When an event is captured by `hanldleGlobalEvent`, when in buffer mode\n * we determine if we want to sample the error or not.\n */\nexport function shouldSampleForBufferEvent(replay: ReplayContainer, event: Event): boolean {\n  if (replay.recordingMode !== 'buffer') {\n    return false;\n  }\n\n  // ignore this error because otherwise we could loop indefinitely with\n  // trying to capture replay and failing\n  if (event.message === UNABLE_TO_SEND_REPLAY) {\n    return false;\n  }\n\n  // Require the event to be an error event & to have an exception\n  if (!event.exception || event.type) {\n    return false;\n  }\n\n  return isSampled(replay.getOptions().errorSampleRate);\n}\n","import { EventType } from '@sentry-internal/rrweb';\n\nimport type { AddEventResult, AllEntryData, ReplayContainer, ReplayPerformanceEntry } from '../types';\n\n/**\n * Create a \"span\" for each performance entry.\n */\nexport function createPerformanceSpans(\n  replay: ReplayContainer,\n  entries: ReplayPerformanceEntry<AllEntryData>[],\n): Promise<AddEventResult | null>[] {\n  return entries.map(({ type, start, end, name, data }) => {\n    const response = replay.throttledAddEvent({\n      type: EventType.Custom,\n      timestamp: start,\n      data: {\n        tag: 'performanceSpan',\n        payload: {\n          op: type,\n          description: name,\n          startTimestamp: start,\n          endTimestamp: end,\n          data,\n        },\n      },\n    });\n\n    // If response is a string, it means its either THROTTLED or SKIPPED\n    return typeof response === 'string' ? Promise.resolve(null) : response;\n  });\n}\n","import type { HandlerDataHistory } from '@sentry/types';\n\nimport type { HistoryData, ReplayContainer, ReplayPerformanceEntry } from '../types';\nimport { createPerformanceSpans } from '../util/createPerformanceSpans';\n\nfunction handleHistory(handlerData: HandlerDataHistory): ReplayPerformanceEntry<HistoryData> {\n  const { from, to } = handlerData;\n\n  const now = Date.now() / 1000;\n\n  return {\n    type: 'navigation.push',\n    start: now,\n    end: now,\n    name: to,\n    data: {\n      previous: from,\n    },\n  };\n}\n\n/**\n * Returns a listener to be added to `addHistoryInstrumentationHandler(listener)`.\n */\nexport function handleHistorySpanListener(replay: ReplayContainer): (handlerData: HandlerDataHistory) => void {\n  return (handlerData: HandlerDataHistory) => {\n    if (!replay.isEnabled()) {\n      return;\n    }\n\n    const result = handleHistory(handlerData);\n\n    if (result === null) {\n      return;\n    }\n\n    // Need to collect visited URLs\n    replay.getContext().urls.push(result.name);\n    replay.triggerUserActivity();\n\n    replay.addUpdate(() => {\n      createPerformanceSpans(replay, [result]);\n      // Returning false to flush\n      return false;\n    });\n  };\n}\n","import type { NetworkRequestData, ReplayContainer, ReplayPerformanceEntry } from '../../types';\nimport { createPerformanceSpans } from '../../util/createPerformanceSpans';\nimport { shouldFilterRequest } from '../../util/shouldFilterRequest';\n\n/** Add a performance entry breadcrumb */\nexport function addNetworkBreadcrumb(\n  replay: ReplayContainer,\n  result: ReplayPerformanceEntry<NetworkRequestData> | null,\n): void {\n  if (!replay.isEnabled()) {\n    return;\n  }\n\n  if (result === null) {\n    return;\n  }\n\n  if (shouldFilterRequest(replay, result.name)) {\n    return;\n  }\n\n  replay.addUpdate(() => {\n    createPerformanceSpans(replay, [result]);\n    // Returning true will cause `addUpdate` to not flush\n    // We do not want network requests to cause a flush. This will prevent\n    // recurring/polling requests from keeping the replay session alive.\n    return true;\n  });\n}\n","import { getClient, isSentryRequestUrl } from '@sentry/core';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport type { ReplayContainer } from '../types';\n\n/**\n * Check whether a given request URL should be filtered out. This is so we\n * don't log Sentry ingest requests.\n */\nexport function shouldFilterRequest(replay: ReplayContainer, url: string): boolean {\n  // If we enabled the `traceInternals` experiment, we want to trace everything\n  if (DEBUG_BUILD && replay.getOptions()._experiments.traceInternals) {\n    return false;\n  }\n\n  return isSentryRequestUrl(url, getClient());\n}\n","import type { HandlerDataXhr } from '@sentry/types';\nimport { SENTRY_XHR_DATA_KEY } from '@sentry/utils';\n\nimport type { NetworkRequestData, ReplayContainer, ReplayPerformanceEntry } from '../types';\nimport { addNetworkBreadcrumb } from './util/addNetworkBreadcrumb';\n\n/** only exported for tests */\nexport function handleXhr(handlerData: HandlerDataXhr): ReplayPerformanceEntry<NetworkRequestData> | null {\n  const { startTimestamp, endTimestamp, xhr } = handlerData;\n\n  const sentryXhrData = xhr[SENTRY_XHR_DATA_KEY];\n\n  if (!startTimestamp || !endTimestamp || !sentryXhrData) {\n    return null;\n  }\n\n  // This is only used as a fallback, so we know the body sizes are never set here\n  const { method, url, status_code: statusCode } = sentryXhrData;\n\n  if (url === undefined) {\n    return null;\n  }\n\n  return {\n    type: 'resource.xhr',\n    name: url,\n    start: startTimestamp / 1000,\n    end: endTimestamp / 1000,\n    data: {\n      method,\n      statusCode,\n    },\n  };\n}\n\n/**\n * Returns a listener to be added to `addXhrInstrumentationHandler(listener)`.\n */\nexport function handleXhrSpanListener(replay: ReplayContainer): (handlerData: HandlerDataXhr) => void {\n  return (handlerData: HandlerDataXhr) => {\n    if (!replay.isEnabled()) {\n      return;\n    }\n\n    const result = handleXhr(handlerData);\n\n    addNetworkBreadcrumb(replay, result);\n  };\n}\n","import type { TextEncoderInternal } from '@sentry/types';\nimport { dropUndefinedKeys, logger, stringMatchesSomePattern } from '@sentry/utils';\n\nimport { NETWORK_BODY_MAX_SIZE, WINDOW } from '../../constants';\nimport { DEBUG_BUILD } from '../../debug-build';\nimport type {\n  NetworkBody,\n  NetworkMetaWarning,\n  NetworkRequestData,\n  ReplayNetworkRequestData,\n  ReplayNetworkRequestOrResponse,\n  ReplayPerformanceEntry,\n} from '../../types';\n\n/** Get the size of a body. */\nexport function getBodySize(\n  body: RequestInit['body'],\n  textEncoder: TextEncoder | TextEncoderInternal,\n): number | undefined {\n  if (!body) {\n    return undefined;\n  }\n\n  try {\n    if (typeof body === 'string') {\n      return textEncoder.encode(body).length;\n    }\n\n    if (body instanceof URLSearchParams) {\n      return textEncoder.encode(body.toString()).length;\n    }\n\n    if (body instanceof FormData) {\n      const formDataStr = _serializeFormData(body);\n      return textEncoder.encode(formDataStr).length;\n    }\n\n    if (body instanceof Blob) {\n      return body.size;\n    }\n\n    if (body instanceof ArrayBuffer) {\n      return body.byteLength;\n    }\n\n    // Currently unhandled types: ArrayBufferView, ReadableStream\n  } catch {\n    // just return undefined\n  }\n\n  return undefined;\n}\n\n/** Convert a Content-Length header to number/undefined.  */\nexport function parseContentLengthHeader(header: string | null | undefined): number | undefined {\n  if (!header) {\n    return undefined;\n  }\n\n  const size = parseInt(header, 10);\n  return isNaN(size) ? undefined : size;\n}\n\n/** Get the string representation of a body. */\nexport function getBodyString(body: unknown): [string | undefined, NetworkMetaWarning?] {\n  try {\n    if (typeof body === 'string') {\n      return [body];\n    }\n\n    if (body instanceof URLSearchParams) {\n      return [body.toString()];\n    }\n\n    if (body instanceof FormData) {\n      return [_serializeFormData(body)];\n    }\n\n    if (!body) {\n      return [undefined];\n    }\n  } catch {\n    DEBUG_BUILD && logger.warn('[Replay] Failed to serialize body', body);\n    return [undefined, 'BODY_PARSE_ERROR'];\n  }\n\n  DEBUG_BUILD && logger.info('[Replay] Skipping network body because of body type', body);\n\n  return [undefined, 'UNPARSEABLE_BODY_TYPE'];\n}\n\n/** Merge a warning into an existing network request/response. */\nexport function mergeWarning(\n  info: ReplayNetworkRequestOrResponse | undefined,\n  warning: NetworkMetaWarning,\n): ReplayNetworkRequestOrResponse {\n  if (!info) {\n    return {\n      headers: {},\n      size: undefined,\n      _meta: {\n        warnings: [warning],\n      },\n    };\n  }\n\n  const newMeta = { ...info._meta };\n  const existingWarnings = newMeta.warnings || [];\n  newMeta.warnings = [...existingWarnings, warning];\n\n  info._meta = newMeta;\n  return info;\n}\n\n/** Convert ReplayNetworkRequestData to a PerformanceEntry. */\nexport function makeNetworkReplayBreadcrumb(\n  type: string,\n  data: ReplayNetworkRequestData | null,\n): ReplayPerformanceEntry<NetworkRequestData> | null {\n  if (!data) {\n    return null;\n  }\n\n  const { startTimestamp, endTimestamp, url, method, statusCode, request, response } = data;\n\n  const result: ReplayPerformanceEntry<NetworkRequestData> = {\n    type,\n    start: startTimestamp / 1000,\n    end: endTimestamp / 1000,\n    name: url,\n    data: dropUndefinedKeys({\n      method,\n      statusCode,\n      request,\n      response,\n    }),\n  };\n\n  return result;\n}\n\n/** Build the request or response part of a replay network breadcrumb that was skipped. */\nexport function buildSkippedNetworkRequestOrResponse(bodySize: number | undefined): ReplayNetworkRequestOrResponse {\n  return {\n    headers: {},\n    size: bodySize,\n    _meta: {\n      warnings: ['URL_SKIPPED'],\n    },\n  };\n}\n\n/** Build the request or response part of a replay network breadcrumb. */\nexport function buildNetworkRequestOrResponse(\n  headers: Record<string, string>,\n  bodySize: number | undefined,\n  body: string | undefined,\n): ReplayNetworkRequestOrResponse | undefined {\n  if (!bodySize && Object.keys(headers).length === 0) {\n    return undefined;\n  }\n\n  if (!bodySize) {\n    return {\n      headers,\n    };\n  }\n\n  if (!body) {\n    return {\n      headers,\n      size: bodySize,\n    };\n  }\n\n  const info: ReplayNetworkRequestOrResponse = {\n    headers,\n    size: bodySize,\n  };\n\n  const { body: normalizedBody, warnings } = normalizeNetworkBody(body);\n  info.body = normalizedBody;\n  if (warnings && warnings.length > 0) {\n    info._meta = {\n      warnings,\n    };\n  }\n\n  return info;\n}\n\n/** Filter a set of headers */\nexport function getAllowedHeaders(headers: Record<string, string>, allowedHeaders: string[]): Record<string, string> {\n  return Object.keys(headers).reduce((filteredHeaders: Record<string, string>, key: string) => {\n    const normalizedKey = key.toLowerCase();\n    // Avoid putting empty strings into the headers\n    if (allowedHeaders.includes(normalizedKey) && headers[key]) {\n      filteredHeaders[normalizedKey] = headers[key];\n    }\n    return filteredHeaders;\n  }, {});\n}\n\nfunction _serializeFormData(formData: FormData): string {\n  // This is a bit simplified, but gives us a decent estimate\n  // This converts e.g. { name: 'Anne Smith', age: 13 } to 'name=Anne+Smith&age=13'\n  // @ts-expect-error passing FormData to URLSearchParams actually works\n  return new URLSearchParams(formData).toString();\n}\n\nfunction normalizeNetworkBody(body: string | undefined): {\n  body: NetworkBody | undefined;\n  warnings?: NetworkMetaWarning[];\n} {\n  if (!body || typeof body !== 'string') {\n    return {\n      body,\n    };\n  }\n\n  const exceedsSizeLimit = body.length > NETWORK_BODY_MAX_SIZE;\n  const isProbablyJson = _strIsProbablyJson(body);\n\n  if (exceedsSizeLimit) {\n    const truncatedBody = body.slice(0, NETWORK_BODY_MAX_SIZE);\n\n    if (isProbablyJson) {\n      return {\n        body: truncatedBody,\n        warnings: ['MAYBE_JSON_TRUNCATED'],\n      };\n    }\n\n    return {\n      body: `${truncatedBody}…`,\n      warnings: ['TEXT_TRUNCATED'],\n    };\n  }\n\n  if (isProbablyJson) {\n    try {\n      const jsonBody = JSON.parse(body);\n      return {\n        body: jsonBody,\n      };\n    } catch {\n      // fall back to just send the body as string\n    }\n  }\n\n  return {\n    body,\n  };\n}\n\nfunction _strIsProbablyJson(str: string): boolean {\n  const first = str[0];\n  const last = str[str.length - 1];\n\n  // Simple check: If this does not start & end with {} or [], it's not JSON\n  return (first === '[' && last === ']') || (first === '{' && last === '}');\n}\n\n/** Match an URL against a list of strings/Regex. */\nexport function urlMatches(url: string, urls: (string | RegExp)[]): boolean {\n  const fullUrl = getFullUrl(url);\n\n  return stringMatchesSomePattern(fullUrl, urls);\n}\n\n/** exported for tests */\nexport function getFullUrl(url: string, baseURI = WINDOW.document.baseURI): string {\n  // Short circuit for common cases:\n  if (url.startsWith('http://') || url.startsWith('https://') || url.startsWith(WINDOW.location.origin)) {\n    return url;\n  }\n  const fixedUrl = new URL(url, baseURI);\n\n  // If these do not match, we are not dealing with a relative URL, so just return it\n  if (fixedUrl.origin !== new URL(baseURI).origin) {\n    return url;\n  }\n\n  const fullUrl = fixedUrl.href;\n\n  // Remove trailing slashes, if they don't match the original URL\n  if (!url.endsWith('/') && fullUrl.endsWith('/')) {\n    return fullUrl.slice(0, -1);\n  }\n\n  return fullUrl;\n}\n","import type { Breadcrumb, FetchBreadcrumbData, TextEncoderInternal } from '@sentry/types';\nimport { logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../../debug-build';\nimport type {\n  FetchHint,\n  NetworkMetaWarning,\n  ReplayContainer,\n  ReplayNetworkOptions,\n  ReplayNetworkRequestData,\n  ReplayNetworkRequestOrResponse,\n} from '../../types';\nimport { addNetworkBreadcrumb } from './addNetworkBreadcrumb';\nimport {\n  buildNetworkRequestOrResponse,\n  buildSkippedNetworkRequestOrResponse,\n  getAllowedHeaders,\n  getBodySize,\n  getBodyString,\n  makeNetworkReplayBreadcrumb,\n  mergeWarning,\n  parseContentLengthHeader,\n  urlMatches,\n} from './networkUtils';\n\n/**\n * Capture a fetch breadcrumb to a replay.\n * This adds additional data (where approriate).\n */\nexport async function captureFetchBreadcrumbToReplay(\n  breadcrumb: Breadcrumb & { data: FetchBreadcrumbData },\n  hint: Partial<FetchHint>,\n  options: ReplayNetworkOptions & {\n    textEncoder: TextEncoderInternal;\n    replay: ReplayContainer;\n  },\n): Promise<void> {\n  try {\n    const data = await _prepareFetchData(breadcrumb, hint, options);\n\n    // Create a replay performance entry from this breadcrumb\n    const result = makeNetworkReplayBreadcrumb('resource.fetch', data);\n    addNetworkBreadcrumb(options.replay, result);\n  } catch (error) {\n    DEBUG_BUILD && logger.error('[Replay] Failed to capture fetch breadcrumb', error);\n  }\n}\n\n/**\n * Enrich a breadcrumb with additional data.\n * This has to be sync & mutate the given breadcrumb,\n * as the breadcrumb is afterwards consumed by other handlers.\n */\nexport function enrichFetchBreadcrumb(\n  breadcrumb: Breadcrumb & { data: FetchBreadcrumbData },\n  hint: Partial<FetchHint>,\n  options: { textEncoder: TextEncoderInternal },\n): void {\n  const { input, response } = hint;\n\n  const body = input ? _getFetchRequestArgBody(input) : undefined;\n  const reqSize = getBodySize(body, options.textEncoder);\n\n  const resSize = response ? parseContentLengthHeader(response.headers.get('content-length')) : undefined;\n\n  if (reqSize !== undefined) {\n    breadcrumb.data.request_body_size = reqSize;\n  }\n  if (resSize !== undefined) {\n    breadcrumb.data.response_body_size = resSize;\n  }\n}\n\nasync function _prepareFetchData(\n  breadcrumb: Breadcrumb & { data: FetchBreadcrumbData },\n  hint: Partial<FetchHint>,\n  options: ReplayNetworkOptions & {\n    textEncoder: TextEncoderInternal;\n  },\n): Promise<ReplayNetworkRequestData> {\n  const now = Date.now();\n  const { startTimestamp = now, endTimestamp = now } = hint;\n\n  const {\n    url,\n    method,\n    status_code: statusCode = 0,\n    request_body_size: requestBodySize,\n    response_body_size: responseBodySize,\n  } = breadcrumb.data;\n\n  const captureDetails =\n    urlMatches(url, options.networkDetailAllowUrls) && !urlMatches(url, options.networkDetailDenyUrls);\n\n  const request = captureDetails\n    ? _getRequestInfo(options, hint.input, requestBodySize)\n    : buildSkippedNetworkRequestOrResponse(requestBodySize);\n  const response = await _getResponseInfo(captureDetails, options, hint.response, responseBodySize);\n\n  return {\n    startTimestamp,\n    endTimestamp,\n    url,\n    method,\n    statusCode,\n    request,\n    response,\n  };\n}\n\nfunction _getRequestInfo(\n  { networkCaptureBodies, networkRequestHeaders }: ReplayNetworkOptions,\n  input: FetchHint['input'] | undefined,\n  requestBodySize?: number,\n): ReplayNetworkRequestOrResponse | undefined {\n  const headers = input ? getRequestHeaders(input, networkRequestHeaders) : {};\n\n  if (!networkCaptureBodies) {\n    return buildNetworkRequestOrResponse(headers, requestBodySize, undefined);\n  }\n\n  // We only want to transmit string or string-like bodies\n  const requestBody = _getFetchRequestArgBody(input);\n  const [bodyStr, warning] = getBodyString(requestBody);\n  const data = buildNetworkRequestOrResponse(headers, requestBodySize, bodyStr);\n\n  if (warning) {\n    return mergeWarning(data, warning);\n  }\n\n  return data;\n}\n\n/** Exported only for tests. */\nexport async function _getResponseInfo(\n  captureDetails: boolean,\n  {\n    networkCaptureBodies,\n    textEncoder,\n    networkResponseHeaders,\n  }: Pick<ReplayNetworkOptions, 'networkCaptureBodies' | 'networkResponseHeaders'> & {\n    textEncoder: TextEncoderInternal;\n  },\n  response: Response | undefined,\n  responseBodySize?: number,\n): Promise<ReplayNetworkRequestOrResponse | undefined> {\n  if (!captureDetails && responseBodySize !== undefined) {\n    return buildSkippedNetworkRequestOrResponse(responseBodySize);\n  }\n\n  const headers = response ? getAllHeaders(response.headers, networkResponseHeaders) : {};\n\n  if (!response || (!networkCaptureBodies && responseBodySize !== undefined)) {\n    return buildNetworkRequestOrResponse(headers, responseBodySize, undefined);\n  }\n\n  const [bodyText, warning] = await _parseFetchResponseBody(response);\n  const result = getResponseData(bodyText, {\n    networkCaptureBodies,\n    textEncoder,\n    responseBodySize,\n    captureDetails,\n    headers,\n  });\n\n  if (warning) {\n    return mergeWarning(result, warning);\n  }\n\n  return result;\n}\n\nfunction getResponseData(\n  bodyText: string | undefined,\n  {\n    networkCaptureBodies,\n    textEncoder,\n    responseBodySize,\n    captureDetails,\n    headers,\n  }: {\n    captureDetails: boolean;\n    networkCaptureBodies: boolean;\n    responseBodySize: number | undefined;\n    headers: Record<string, string>;\n    textEncoder: TextEncoderInternal;\n  },\n): ReplayNetworkRequestOrResponse | undefined {\n  try {\n    const size =\n      bodyText && bodyText.length && responseBodySize === undefined\n        ? getBodySize(bodyText, textEncoder)\n        : responseBodySize;\n\n    if (!captureDetails) {\n      return buildSkippedNetworkRequestOrResponse(size);\n    }\n\n    if (networkCaptureBodies) {\n      return buildNetworkRequestOrResponse(headers, size, bodyText);\n    }\n\n    return buildNetworkRequestOrResponse(headers, size, undefined);\n  } catch (error) {\n    DEBUG_BUILD && logger.warn('[Replay] Failed to serialize response body', error);\n    // fallback\n    return buildNetworkRequestOrResponse(headers, responseBodySize, undefined);\n  }\n}\n\nasync function _parseFetchResponseBody(response: Response): Promise<[string | undefined, NetworkMetaWarning?]> {\n  const res = _tryCloneResponse(response);\n\n  if (!res) {\n    return [undefined, 'BODY_PARSE_ERROR'];\n  }\n\n  try {\n    const text = await _tryGetResponseText(res);\n    return [text];\n  } catch (error) {\n    DEBUG_BUILD && logger.warn('[Replay] Failed to get text body from response', error);\n    return [undefined, 'BODY_PARSE_ERROR'];\n  }\n}\n\nfunction _getFetchRequestArgBody(fetchArgs: unknown[] = []): RequestInit['body'] | undefined {\n  // We only support getting the body from the fetch options\n  if (fetchArgs.length !== 2 || typeof fetchArgs[1] !== 'object') {\n    return undefined;\n  }\n\n  return (fetchArgs[1] as RequestInit).body;\n}\n\nfunction getAllHeaders(headers: Headers, allowedHeaders: string[]): Record<string, string> {\n  const allHeaders: Record<string, string> = {};\n\n  allowedHeaders.forEach(header => {\n    if (headers.get(header)) {\n      allHeaders[header] = headers.get(header) as string;\n    }\n  });\n\n  return allHeaders;\n}\n\nfunction getRequestHeaders(fetchArgs: unknown[], allowedHeaders: string[]): Record<string, string> {\n  if (fetchArgs.length === 1 && typeof fetchArgs[0] !== 'string') {\n    return getHeadersFromOptions(fetchArgs[0] as Request | RequestInit, allowedHeaders);\n  }\n\n  if (fetchArgs.length === 2) {\n    return getHeadersFromOptions(fetchArgs[1] as Request | RequestInit, allowedHeaders);\n  }\n\n  return {};\n}\n\nfunction getHeadersFromOptions(\n  input: Request | RequestInit | undefined,\n  allowedHeaders: string[],\n): Record<string, string> {\n  if (!input) {\n    return {};\n  }\n\n  const headers = input.headers;\n\n  if (!headers) {\n    return {};\n  }\n\n  if (headers instanceof Headers) {\n    return getAllHeaders(headers, allowedHeaders);\n  }\n\n  // We do not support this, as it is not really documented (anymore?)\n  if (Array.isArray(headers)) {\n    return {};\n  }\n\n  return getAllowedHeaders(headers, allowedHeaders);\n}\n\nfunction _tryCloneResponse(response: Response): Response | void {\n  try {\n    // We have to clone this, as the body can only be read once\n    return response.clone();\n  } catch (error) {\n    // this can throw if the response was already consumed before\n    DEBUG_BUILD && logger.warn('[Replay] Failed to clone response body', error);\n  }\n}\n\n/**\n * Get the response body of a fetch request, or timeout after 500ms.\n * Fetch can return a streaming body, that may not resolve (or not for a long time).\n * If that happens, we rather abort after a short time than keep waiting for this.\n */\nfunction _tryGetResponseText(response: Response): Promise<string | undefined> {\n  return new Promise((resolve, reject) => {\n    const timeout = setTimeout(() => reject(new Error('Timeout while trying to read response body')), 500);\n\n    _getResponseText(response)\n      .then(\n        txt => resolve(txt),\n        reason => reject(reason),\n      )\n      .finally(() => clearTimeout(timeout));\n  });\n\n  return _getResponseText(response);\n}\n\nasync function _getResponseText(response: Response): Promise<string> {\n  // Force this to be a promise, just to be safe\n  // eslint-disable-next-line no-return-await\n  return await response.text();\n}\n","import type { Breadcrumb, TextEncoderInternal, XhrBreadcrumbData } from '@sentry/types';\nimport { SENTRY_XHR_DATA_KEY, logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../../debug-build';\nimport type {\n  NetworkMetaWarning,\n  ReplayContainer,\n  ReplayNetworkOptions,\n  ReplayNetworkRequestData,\n  XhrHint,\n} from '../../types';\nimport { addNetworkBreadcrumb } from './addNetworkBreadcrumb';\nimport {\n  buildNetworkRequestOrResponse,\n  buildSkippedNetworkRequestOrResponse,\n  getAllowedHeaders,\n  getBodySize,\n  getBodyString,\n  makeNetworkReplayBreadcrumb,\n  mergeWarning,\n  parseContentLengthHeader,\n  urlMatches,\n} from './networkUtils';\n\n/**\n * Capture an XHR breadcrumb to a replay.\n * This adds additional data (where approriate).\n */\nexport async function captureXhrBreadcrumbToReplay(\n  breadcrumb: Breadcrumb & { data: XhrBreadcrumbData },\n  hint: Partial<XhrHint>,\n  options: ReplayNetworkOptions & { replay: ReplayContainer },\n): Promise<void> {\n  try {\n    const data = _prepareXhrData(breadcrumb, hint, options);\n\n    // Create a replay performance entry from this breadcrumb\n    const result = makeNetworkReplayBreadcrumb('resource.xhr', data);\n    addNetworkBreadcrumb(options.replay, result);\n  } catch (error) {\n    DEBUG_BUILD && logger.error('[Replay] Failed to capture xhr breadcrumb', error);\n  }\n}\n\n/**\n * Enrich a breadcrumb with additional data.\n * This has to be sync & mutate the given breadcrumb,\n * as the breadcrumb is afterwards consumed by other handlers.\n */\nexport function enrichXhrBreadcrumb(\n  breadcrumb: Breadcrumb & { data: XhrBreadcrumbData },\n  hint: Partial<XhrHint>,\n  options: { textEncoder: TextEncoderInternal },\n): void {\n  const { xhr, input } = hint;\n\n  if (!xhr) {\n    return;\n  }\n\n  const reqSize = getBodySize(input, options.textEncoder);\n  const resSize = xhr.getResponseHeader('content-length')\n    ? parseContentLengthHeader(xhr.getResponseHeader('content-length'))\n    : _getBodySize(xhr.response, xhr.responseType, options.textEncoder);\n\n  if (reqSize !== undefined) {\n    breadcrumb.data.request_body_size = reqSize;\n  }\n  if (resSize !== undefined) {\n    breadcrumb.data.response_body_size = resSize;\n  }\n}\n\nfunction _prepareXhrData(\n  breadcrumb: Breadcrumb & { data: XhrBreadcrumbData },\n  hint: Partial<XhrHint>,\n  options: ReplayNetworkOptions,\n): ReplayNetworkRequestData | null {\n  const now = Date.now();\n  const { startTimestamp = now, endTimestamp = now, input, xhr } = hint;\n\n  const {\n    url,\n    method,\n    status_code: statusCode = 0,\n    request_body_size: requestBodySize,\n    response_body_size: responseBodySize,\n  } = breadcrumb.data;\n\n  if (!url) {\n    return null;\n  }\n\n  if (!xhr || !urlMatches(url, options.networkDetailAllowUrls) || urlMatches(url, options.networkDetailDenyUrls)) {\n    const request = buildSkippedNetworkRequestOrResponse(requestBodySize);\n    const response = buildSkippedNetworkRequestOrResponse(responseBodySize);\n    return {\n      startTimestamp,\n      endTimestamp,\n      url,\n      method,\n      statusCode,\n      request,\n      response,\n    };\n  }\n\n  const xhrInfo = xhr[SENTRY_XHR_DATA_KEY];\n  const networkRequestHeaders = xhrInfo\n    ? getAllowedHeaders(xhrInfo.request_headers, options.networkRequestHeaders)\n    : {};\n  const networkResponseHeaders = getAllowedHeaders(getResponseHeaders(xhr), options.networkResponseHeaders);\n\n  const [requestBody, requestWarning] = options.networkCaptureBodies ? getBodyString(input) : [undefined];\n  const [responseBody, responseWarning] = options.networkCaptureBodies ? _getXhrResponseBody(xhr) : [undefined];\n\n  const request = buildNetworkRequestOrResponse(networkRequestHeaders, requestBodySize, requestBody);\n  const response = buildNetworkRequestOrResponse(networkResponseHeaders, responseBodySize, responseBody);\n\n  return {\n    startTimestamp,\n    endTimestamp,\n    url,\n    method,\n    statusCode,\n    request: requestWarning ? mergeWarning(request, requestWarning) : request,\n    response: responseWarning ? mergeWarning(response, responseWarning) : response,\n  };\n}\n\nfunction getResponseHeaders(xhr: XMLHttpRequest): Record<string, string> {\n  const headers = xhr.getAllResponseHeaders();\n\n  if (!headers) {\n    return {};\n  }\n\n  return headers.split('\\r\\n').reduce((acc: Record<string, string>, line: string) => {\n    const [key, value] = line.split(': ');\n    acc[key.toLowerCase()] = value;\n    return acc;\n  }, {});\n}\n\nfunction _getXhrResponseBody(xhr: XMLHttpRequest): [string | undefined, NetworkMetaWarning?] {\n  // We collect errors that happen, but only log them if we can't get any response body\n  const errors: unknown[] = [];\n\n  try {\n    return [xhr.responseText];\n  } catch (e) {\n    errors.push(e);\n  }\n\n  // Try to manually parse the response body, if responseText fails\n  try {\n    return _parseXhrResponse(xhr.response, xhr.responseType);\n  } catch (e) {\n    errors.push(e);\n  }\n\n  DEBUG_BUILD && logger.warn('[Replay] Failed to get xhr response body', ...errors);\n\n  return [undefined];\n}\n\n/**\n * Get the string representation of the XHR response.\n * Based on MDN, these are the possible types of the response:\n * string\n * ArrayBuffer\n * Blob\n * Document\n * POJO\n *\n * Exported only for tests.\n */\nexport function _parseXhrResponse(\n  body: XMLHttpRequest['response'],\n  responseType: XMLHttpRequest['responseType'],\n): [string | undefined, NetworkMetaWarning?] {\n  try {\n    if (typeof body === 'string') {\n      return [body];\n    }\n\n    if (body instanceof Document) {\n      return [body.body.outerHTML];\n    }\n\n    if (responseType === 'json' && body && typeof body === 'object') {\n      return [JSON.stringify(body)];\n    }\n\n    if (!body) {\n      return [undefined];\n    }\n  } catch {\n    DEBUG_BUILD && logger.warn('[Replay] Failed to serialize body', body);\n    return [undefined, 'BODY_PARSE_ERROR'];\n  }\n\n  DEBUG_BUILD && logger.info('[Replay] Skipping network body because of body type', body);\n\n  return [undefined, 'UNPARSEABLE_BODY_TYPE'];\n}\n\nfunction _getBodySize(\n  body: XMLHttpRequest['response'],\n  responseType: XMLHttpRequest['responseType'],\n  textEncoder: TextEncoder | TextEncoderInternal,\n): number | undefined {\n  try {\n    const bodyStr = responseType === 'json' && body && typeof body === 'object' ? JSON.stringify(body) : body;\n    return getBodySize(bodyStr, textEncoder);\n  } catch {\n    return undefined;\n  }\n}\n","import { getClient } from '@sentry/core';\nimport type {\n  Breadcrumb,\n  BreadcrumbHint,\n  FetchBreadcrumbData,\n  TextEncoderInternal,\n  XhrBreadcrumbData,\n} from '@sentry/types';\nimport { addFetchInstrumentationHandler, addXhrInstrumentationHandler, logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport type { FetchHint, ReplayContainer, ReplayNetworkOptions, XhrHint } from '../types';\nimport { handleFetchSpanListener } from './handleFetch';\nimport { handleXhrSpanListener } from './handleXhr';\nimport { captureFetchBreadcrumbToReplay, enrichFetchBreadcrumb } from './util/fetchUtils';\nimport { captureXhrBreadcrumbToReplay, enrichXhrBreadcrumb } from './util/xhrUtils';\n\ninterface ExtendedNetworkBreadcrumbsOptions extends ReplayNetworkOptions {\n  replay: ReplayContainer;\n  textEncoder: TextEncoderInternal;\n}\n\n/**\n * This method does two things:\n * - It enriches the regular XHR/fetch breadcrumbs with request/response size data\n * - It captures the XHR/fetch breadcrumbs to the replay\n *   (enriching it with further data that is _not_ added to the regular breadcrumbs)\n */\nexport function handleNetworkBreadcrumbs(replay: ReplayContainer): void {\n  const client = getClient();\n\n  try {\n    const textEncoder = new TextEncoder();\n\n    const {\n      networkDetailAllowUrls,\n      networkDetailDenyUrls,\n      networkCaptureBodies,\n      networkRequestHeaders,\n      networkResponseHeaders,\n    } = replay.getOptions();\n\n    const options: ExtendedNetworkBreadcrumbsOptions = {\n      replay,\n      textEncoder,\n      networkDetailAllowUrls,\n      networkDetailDenyUrls,\n      networkCaptureBodies,\n      networkRequestHeaders,\n      networkResponseHeaders,\n    };\n\n    if (client && client.on) {\n      client.on('beforeAddBreadcrumb', (breadcrumb, hint) => beforeAddNetworkBreadcrumb(options, breadcrumb, hint));\n    } else {\n      // Fallback behavior\n      addFetchInstrumentationHandler(handleFetchSpanListener(replay));\n      addXhrInstrumentationHandler(handleXhrSpanListener(replay));\n    }\n  } catch {\n    // Do nothing\n  }\n}\n\n/** just exported for tests */\nexport function beforeAddNetworkBreadcrumb(\n  options: ExtendedNetworkBreadcrumbsOptions,\n  breadcrumb: Breadcrumb,\n  hint?: BreadcrumbHint,\n): void {\n  if (!breadcrumb.data) {\n    return;\n  }\n\n  try {\n    if (_isXhrBreadcrumb(breadcrumb) && _isXhrHint(hint)) {\n      // This has to be sync, as we need to ensure the breadcrumb is enriched in the same tick\n      // Because the hook runs synchronously, and the breadcrumb is afterwards passed on\n      // So any async mutations to it will not be reflected in the final breadcrumb\n      enrichXhrBreadcrumb(breadcrumb, hint, options);\n\n      // This call should not reject\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      captureXhrBreadcrumbToReplay(breadcrumb, hint, options);\n    }\n\n    if (_isFetchBreadcrumb(breadcrumb) && _isFetchHint(hint)) {\n      // This has to be sync, as we need to ensure the breadcrumb is enriched in the same tick\n      // Because the hook runs synchronously, and the breadcrumb is afterwards passed on\n      // So any async mutations to it will not be reflected in the final breadcrumb\n      enrichFetchBreadcrumb(breadcrumb, hint, options);\n\n      // This call should not reject\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      captureFetchBreadcrumbToReplay(breadcrumb, hint, options);\n    }\n  } catch (e) {\n    DEBUG_BUILD && logger.warn('Error when enriching network breadcrumb');\n  }\n}\n\nfunction _isXhrBreadcrumb(breadcrumb: Breadcrumb): breadcrumb is Breadcrumb & { data: XhrBreadcrumbData } {\n  return breadcrumb.category === 'xhr';\n}\n\nfunction _isFetchBreadcrumb(breadcrumb: Breadcrumb): breadcrumb is Breadcrumb & { data: FetchBreadcrumbData } {\n  return breadcrumb.category === 'fetch';\n}\n\nfunction _isXhrHint(hint?: BreadcrumbHint): hint is XhrHint {\n  return hint && hint.xhr;\n}\n\nfunction _isFetchHint(hint?: BreadcrumbHint): hint is FetchHint {\n  return hint && hint.response;\n}\n","import type { HandlerDataFetch } from '@sentry/types';\n\nimport type { NetworkRequestData, ReplayContainer, ReplayPerformanceEntry } from '../types';\nimport { addNetworkBreadcrumb } from './util/addNetworkBreadcrumb';\n\n/** only exported for tests */\nexport function handleFetch(handlerData: HandlerDataFetch): null | ReplayPerformanceEntry<NetworkRequestData> {\n  const { startTimestamp, endTimestamp, fetchData, response } = handlerData;\n\n  if (!endTimestamp) {\n    return null;\n  }\n\n  // This is only used as a fallback, so we know the body sizes are never set here\n  const { method, url } = fetchData;\n\n  return {\n    type: 'resource.fetch',\n    start: startTimestamp / 1000,\n    end: endTimestamp / 1000,\n    name: url,\n    data: {\n      method,\n      statusCode: response ? (response as Response).status : undefined,\n    },\n  };\n}\n\n/**\n * Returns a listener to be added to `addFetchInstrumentationHandler(listener)`.\n */\nexport function handleFetchSpanListener(replay: ReplayContainer): (handlerData: HandlerDataFetch) => void {\n  return (handlerData: HandlerDataFetch) => {\n    if (!replay.isEnabled()) {\n      return;\n    }\n\n    const result = handleFetch(handlerData);\n\n    addNetworkBreadcrumb(replay, result);\n  };\n}\n","import type { Breadcrumb, Scope } from '@sentry/types';\nimport { normalize } from '@sentry/utils';\n\nimport { CONSOLE_ARG_MAX_SIZE } from '../constants';\nimport type { ReplayContainer } from '../types';\nimport type { ReplayFrame } from '../types/replayFrame';\nimport { createBreadcrumb } from '../util/createBreadcrumb';\nimport { addBreadcrumbEvent } from './util/addBreadcrumbEvent';\n\nlet _LAST_BREADCRUMB: null | Breadcrumb = null;\n\ntype BreadcrumbWithCategory = Required<Pick<Breadcrumb, 'category'>>;\n\nfunction isBreadcrumbWithCategory(breadcrumb: Breadcrumb): breadcrumb is BreadcrumbWithCategory {\n  return !!breadcrumb.category;\n}\n\nexport const handleScopeListener: (replay: ReplayContainer) => (scope: Scope) => void =\n  (replay: ReplayContainer) =>\n  (scope: Scope): void => {\n    if (!replay.isEnabled()) {\n      return;\n    }\n\n    const result = handleScope(scope);\n\n    if (!result) {\n      return;\n    }\n\n    addBreadcrumbEvent(replay, result);\n  };\n\n/**\n * An event handler to handle scope changes.\n */\nexport function handleScope(scope: Scope): Breadcrumb | null {\n  // TODO (v8): Remove this guard. This was put in place because we introduced\n  // Scope.getLastBreadcrumb mid-v7 which caused incompatibilities with older SDKs.\n  // For now, we'll just return null if the method doesn't exist but we should eventually\n  // get rid of this guard.\n  const newBreadcrumb = scope.getLastBreadcrumb && scope.getLastBreadcrumb();\n\n  // Listener can be called when breadcrumbs have not changed, so we store the\n  // reference to the last crumb and only return a crumb if it has changed\n  if (_LAST_BREADCRUMB === newBreadcrumb || !newBreadcrumb) {\n    return null;\n  }\n\n  _LAST_BREADCRUMB = newBreadcrumb;\n\n  if (\n    !isBreadcrumbWithCategory(newBreadcrumb) ||\n    ['fetch', 'xhr', 'sentry.event', 'sentry.transaction'].includes(newBreadcrumb.category) ||\n    newBreadcrumb.category.startsWith('ui.')\n  ) {\n    return null;\n  }\n\n  if (newBreadcrumb.category === 'console') {\n    return normalizeConsoleBreadcrumb(newBreadcrumb);\n  }\n\n  return createBreadcrumb(newBreadcrumb);\n}\n\n/** exported for tests only */\nexport function normalizeConsoleBreadcrumb(\n  breadcrumb: Omit<Breadcrumb, 'category'> & BreadcrumbWithCategory,\n): ReplayFrame {\n  const args = breadcrumb.data && breadcrumb.data.arguments;\n\n  if (!Array.isArray(args) || args.length === 0) {\n    return createBreadcrumb(breadcrumb);\n  }\n\n  let isTruncated = false;\n\n  // Avoid giant args captures\n  const normalizedArgs = args.map(arg => {\n    if (!arg) {\n      return arg;\n    }\n    if (typeof arg === 'string') {\n      if (arg.length > CONSOLE_ARG_MAX_SIZE) {\n        isTruncated = true;\n        return `${arg.slice(0, CONSOLE_ARG_MAX_SIZE)}…`;\n      }\n\n      return arg;\n    }\n    if (typeof arg === 'object') {\n      try {\n        const normalizedArg = normalize(arg, 7);\n        const stringified = JSON.stringify(normalizedArg);\n        if (stringified.length > CONSOLE_ARG_MAX_SIZE) {\n          isTruncated = true;\n          // We use the pretty printed JSON string here as a base\n          return `${JSON.stringify(normalizedArg, null, 2).slice(0, CONSOLE_ARG_MAX_SIZE)}…`;\n        }\n        return normalizedArg;\n      } catch {\n        // fall back to default\n      }\n    }\n\n    return arg;\n  });\n\n  return createBreadcrumb({\n    ...breadcrumb,\n    data: {\n      ...breadcrumb.data,\n      arguments: normalizedArgs,\n      ...(isTruncated ? { _meta: { warnings: ['CONSOLE_ARG_TRUNCATED'] } } : {}),\n    },\n  });\n}\n","import type { BaseClient } from '@sentry/core';\nimport { getCurrentScope } from '@sentry/core';\nimport { addEventProcessor, getClient } from '@sentry/core';\nimport type { Client, DynamicSamplingContext } from '@sentry/types';\nimport { addClickKeypressInstrumentationHandler, addHistoryInstrumentationHandler } from '@sentry/utils';\n\nimport { handleAfterSendEvent } from '../coreHandlers/handleAfterSendEvent';\nimport { handleBeforeSendEvent } from '../coreHandlers/handleBeforeSendEvent';\nimport { handleDomListener } from '../coreHandlers/handleDom';\nimport { handleGlobalEventListener } from '../coreHandlers/handleGlobalEvent';\nimport { handleHistorySpanListener } from '../coreHandlers/handleHistory';\nimport { handleNetworkBreadcrumbs } from '../coreHandlers/handleNetworkBreadcrumbs';\nimport { handleScopeListener } from '../coreHandlers/handleScope';\nimport type { ReplayContainer } from '../types';\n\n/**\n * Add global listeners that cannot be removed.\n */\nexport function addGlobalListeners(replay: ReplayContainer): void {\n  // Listeners from core SDK //\n  const scope = getCurrentScope();\n  const client = getClient();\n\n  scope.addScopeListener(handleScopeListener(replay));\n  addClickKeypressInstrumentationHandler(handleDomListener(replay));\n  addHistoryInstrumentationHandler(handleHistorySpanListener(replay));\n  handleNetworkBreadcrumbs(replay);\n\n  // Tag all (non replay) events that get sent to Sentry with the current\n  // replay ID so that we can reference them later in the UI\n  const eventProcessor = handleGlobalEventListener(replay, !hasHooks(client));\n  if (client && client.addEventProcessor) {\n    client.addEventProcessor(eventProcessor);\n  } else {\n    addEventProcessor(eventProcessor);\n  }\n\n  // If a custom client has no hooks yet, we continue to use the \"old\" implementation\n  if (hasHooks(client)) {\n    client.on('beforeSendEvent', handleBeforeSendEvent(replay));\n    client.on('afterSendEvent', handleAfterSendEvent(replay));\n    client.on('createDsc', (dsc: DynamicSamplingContext) => {\n      const replayId = replay.getSessionId();\n      // We do not want to set the DSC when in buffer mode, as that means the replay has not been sent (yet)\n      if (replayId && replay.isEnabled() && replay.recordingMode === 'session') {\n        // Ensure to check that the session is still active - it could have expired in the meanwhile\n        const isSessionActive = replay.checkAndHandleExpiredSession();\n        if (isSessionActive) {\n          dsc.replay_id = replayId;\n        }\n      }\n    });\n\n    client.on('startTransaction', transaction => {\n      replay.lastTransaction = transaction;\n    });\n\n    // We may be missing the initial startTransaction due to timing issues,\n    // so we capture it on finish again.\n    client.on('finishTransaction', transaction => {\n      replay.lastTransaction = transaction;\n    });\n\n    // We want to flush replay\n    client.on('beforeSendFeedback', (feedbackEvent, options) => {\n      const replayId = replay.getSessionId();\n      if (options && options.includeReplay && replay.isEnabled() && replayId) {\n        // This should never reject\n        if (feedbackEvent.contexts && feedbackEvent.contexts.feedback) {\n          feedbackEvent.contexts.feedback.replay_id = replayId;\n        }\n      }\n    });\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction hasHooks(client: Client | undefined): client is BaseClient<any> {\n  return !!(client && client.on);\n}\n","import { WINDOW } from '../constants';\nimport type { AddEventResult, MemoryData, ReplayContainer, ReplayPerformanceEntry } from '../types';\nimport { createPerformanceSpans } from './createPerformanceSpans';\n\ntype ReplayMemoryEntry = ReplayPerformanceEntry<MemoryData> & { data: { memory: MemoryInfo } };\n\ninterface MemoryInfo {\n  jsHeapSizeLimit: number;\n  totalJSHeapSize: number;\n  usedJSHeapSize: number;\n}\n\n/**\n * Create a \"span\" for the total amount of memory being used by JS objects\n * (including v8 internal objects).\n */\nexport async function addMemoryEntry(replay: ReplayContainer): Promise<Array<AddEventResult | null>> {\n  // window.performance.memory is a non-standard API and doesn't work on all browsers, so we try-catch this\n  try {\n    return Promise.all(\n      createPerformanceSpans(replay, [\n        // @ts-expect-error memory doesn't exist on type Performance as the API is non-standard (we check that it exists above)\n        createMemoryEntry(WINDOW.performance.memory),\n      ]),\n    );\n  } catch (error) {\n    // Do nothing\n    return [];\n  }\n}\n\nfunction createMemoryEntry(memoryEntry: MemoryInfo): ReplayMemoryEntry {\n  const { jsHeapSizeLimit, totalJSHeapSize, usedJSHeapSize } = memoryEntry;\n  // we don't want to use `getAbsoluteTime` because it adds the event time to the\n  // time origin, so we get the current timestamp instead\n  const time = Date.now() / 1000;\n  return {\n    type: 'memory',\n    name: 'memory',\n    start: time,\n    end: time,\n    data: {\n      memory: {\n        jsHeapSizeLimit,\n        totalJSHeapSize,\n        usedJSHeapSize,\n      },\n    },\n  };\n}\n","import { EventType } from '@sentry-internal/rrweb';\nimport { logger } from '@sentry/utils';\n\nimport { updateClickDetectorForRecordingEvent } from '../coreHandlers/handleClick';\nimport { DEBUG_BUILD } from '../debug-build';\nimport { saveSession } from '../session/saveSession';\nimport type { RecordingEvent, ReplayContainer, ReplayOptionFrameEvent } from '../types';\nimport { addEventSync } from './addEvent';\nimport { logInfo } from './log';\n\ntype RecordingEmitCallback = (event: RecordingEvent, isCheckout?: boolean) => void;\n\n/**\n * Handler for recording events.\n *\n * Adds to event buffer, and has varying flushing behaviors if the event was a checkout.\n */\nexport function getHandleRecordingEmit(replay: ReplayContainer): RecordingEmitCallback {\n  let hadFirstEvent = false;\n\n  return (event: RecordingEvent, _isCheckout?: boolean) => {\n    // If this is false, it means session is expired, create and a new session and wait for checkout\n    if (!replay.checkAndHandleExpiredSession()) {\n      DEBUG_BUILD && logger.warn('[Replay] Received replay event after session expired.');\n\n      return;\n    }\n\n    // `_isCheckout` is only set when the checkout is due to `checkoutEveryNms`\n    // We also want to treat the first event as a checkout, so we handle this specifically here\n    const isCheckout = _isCheckout || !hadFirstEvent;\n    hadFirstEvent = true;\n\n    if (replay.clickDetector) {\n      updateClickDetectorForRecordingEvent(replay.clickDetector, event);\n    }\n\n    // The handler returns `true` if we do not want to trigger debounced flush, `false` if we want to debounce flush.\n    replay.addUpdate(() => {\n      // The session is always started immediately on pageload/init, but for\n      // error-only replays, it should reflect the most recent checkout\n      // when an error occurs. Clear any state that happens before this current\n      // checkout. This needs to happen before `addEvent()` which updates state\n      // dependent on this reset.\n      if (replay.recordingMode === 'buffer' && isCheckout) {\n        replay.setInitialState();\n      }\n\n      // If the event is not added (e.g. due to being paused, disabled, or out of the max replay duration),\n      // Skip all further steps\n      if (!addEventSync(replay, event, isCheckout)) {\n        // Return true to skip scheduling a debounced flush\n        return true;\n      }\n\n      // Different behavior for full snapshots (type=2), ignore other event types\n      // See https://github.com/rrweb-io/rrweb/blob/d8f9290ca496712aa1e7d472549480c4e7876594/packages/rrweb/src/types.ts#L16\n      if (!isCheckout) {\n        return false;\n      }\n\n      // Additionally, create a meta event that will capture certain SDK settings.\n      // In order to handle buffer mode, this needs to either be done when we\n      // receive checkout events or at flush time.\n      //\n      // `isCheckout` is always true, but want to be explicit that it should\n      // only be added for checkouts\n      addSettingsEvent(replay, isCheckout);\n\n      // If there is a previousSessionId after a full snapshot occurs, then\n      // the replay session was started due to session expiration. The new session\n      // is started before triggering a new checkout and contains the id\n      // of the previous session. Do not immediately flush in this case\n      // to avoid capturing only the checkout and instead the replay will\n      // be captured if they perform any follow-up actions.\n      if (replay.session && replay.session.previousSessionId) {\n        return true;\n      }\n\n      // When in buffer mode, make sure we adjust the session started date to the current earliest event of the buffer\n      // this should usually be the timestamp of the checkout event, but to be safe...\n      if (replay.recordingMode === 'buffer' && replay.session && replay.eventBuffer) {\n        const earliestEvent = replay.eventBuffer.getEarliestTimestamp();\n        if (earliestEvent) {\n          logInfo(\n            `[Replay] Updating session start time to earliest event in buffer to ${new Date(earliestEvent)}`,\n            replay.getOptions()._experiments.traceInternals,\n          );\n\n          replay.session.started = earliestEvent;\n\n          if (replay.getOptions().stickySession) {\n            saveSession(replay.session);\n          }\n        }\n      }\n\n      if (replay.recordingMode === 'session') {\n        // If the full snapshot is due to an initial load, we will not have\n        // a previous session ID. In this case, we want to buffer events\n        // for a set amount of time before flushing. This can help avoid\n        // capturing replays of users that immediately close the window.\n\n        // This should never reject\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        void replay.flush();\n      }\n\n      return true;\n    });\n  };\n}\n\n/**\n * Exported for tests\n */\nexport function createOptionsEvent(replay: ReplayContainer): ReplayOptionFrameEvent {\n  const options = replay.getOptions();\n  return {\n    type: EventType.Custom,\n    timestamp: Date.now(),\n    data: {\n      tag: 'options',\n      payload: {\n        shouldRecordCanvas: replay.isRecordingCanvas(),\n        sessionSampleRate: options.sessionSampleRate,\n        errorSampleRate: options.errorSampleRate,\n        useCompressionOption: options.useCompression,\n        blockAllMedia: options.blockAllMedia,\n        maskAllText: options.maskAllText,\n        maskAllInputs: options.maskAllInputs,\n        useCompression: replay.eventBuffer ? replay.eventBuffer.type === 'worker' : false,\n        networkDetailHasUrls: options.networkDetailAllowUrls.length > 0,\n        networkCaptureBodies: options.networkCaptureBodies,\n        networkRequestHasHeaders: options.networkRequestHeaders.length > 0,\n        networkResponseHasHeaders: options.networkResponseHeaders.length > 0,\n      },\n    },\n  };\n}\n\n/**\n * Add a \"meta\" event that contains a simplified view on current configuration\n * options. This should only be included on the first segment of a recording.\n */\nfunction addSettingsEvent(replay: ReplayContainer, isCheckout?: boolean): void {\n  // Only need to add this event when sending the first segment\n  if (!isCheckout || !replay.session || replay.session.segmentId !== 0) {\n    return;\n  }\n\n  addEventSync(replay, createOptionsEvent(replay), false);\n}\n","import type { DsnComponents, ReplayEnvelope, ReplayEvent, ReplayRecordingData } from '@sentry/types';\nimport { createEnvelope, createEventEnvelopeHeaders, getSdkMetadataForEnvelopeHeader } from '@sentry/utils';\n\n/**\n * Create a replay envelope ready to be sent.\n * This includes both the replay event, as well as the recording data.\n */\nexport function createReplayEnvelope(\n  replayEvent: ReplayEvent,\n  recordingData: ReplayRecordingData,\n  dsn: DsnComponents,\n  tunnel?: string,\n): ReplayEnvelope {\n  return createEnvelope<ReplayEnvelope>(\n    createEventEnvelopeHeaders(replayEvent, getSdkMetadataForEnvelopeHeader(replayEvent), tunnel, dsn),\n    [\n      [{ type: 'replay_event' }, replayEvent],\n      [\n        {\n          type: 'replay_recording',\n          // If string then we need to encode to UTF8, otherwise will have\n          // wrong size. TextEncoder has similar browser support to\n          // MutationObserver, although it does not accept IE11.\n          length:\n            typeof recordingData === 'string' ? new TextEncoder().encode(recordingData).length : recordingData.length,\n        },\n        recordingData,\n      ],\n    ],\n  );\n}\n","import type { ReplayRecordingData } from '@sentry/types';\n\n/**\n * Prepare the recording data ready to be sent.\n */\nexport function prepareRecordingData({\n  recordingData,\n  headers,\n}: {\n  recordingData: ReplayRecordingData;\n  headers: Record<string, unknown>;\n}): ReplayRecordingData {\n  let payloadWithSequence;\n\n  // XXX: newline is needed to separate sequence id from events\n  const replayHeaders = `${JSON.stringify(headers)}\n`;\n\n  if (typeof recordingData === 'string') {\n    payloadWithSequence = `${replayHeaders}${recordingData}`;\n  } else {\n    const enc = new TextEncoder();\n    // XXX: newline is needed to separate sequence id from events\n    const sequence = enc.encode(replayHeaders);\n    // Merge the two Uint8Arrays\n    payloadWithSequence = new Uint8Array(sequence.length + recordingData.length);\n    payloadWithSequence.set(sequence);\n    payloadWithSequence.set(recordingData, sequence.length);\n  }\n\n  return payloadWithSequence;\n}\n","import type { IntegrationIndex, Scope } from '@sentry/core';\nimport { getIsolationScope } from '@sentry/core';\nimport { prepareEvent } from '@sentry/core';\nimport type { Client, EventHint, ReplayEvent } from '@sentry/types';\n\n/**\n * Prepare a replay event & enrich it with the SDK metadata.\n */\nexport async function prepareReplayEvent({\n  client,\n  scope,\n  replayId: event_id,\n  event,\n}: {\n  client: Client & { _integrations?: IntegrationIndex };\n  scope: Scope;\n  replayId: string;\n  event: ReplayEvent;\n}): Promise<ReplayEvent | null> {\n  const integrations =\n    typeof client._integrations === 'object' && client._integrations !== null && !Array.isArray(client._integrations)\n      ? Object.keys(client._integrations)\n      : undefined;\n\n  const eventHint: EventHint = { event_id, integrations };\n\n  if (client.emit) {\n    client.emit('preprocessEvent', event, eventHint);\n  }\n\n  const preparedEvent = (await prepareEvent(\n    client.getOptions(),\n    event,\n    eventHint,\n    scope,\n    client,\n    getIsolationScope(),\n  )) as ReplayEvent | null;\n\n  // If e.g. a global event processor returned null\n  if (!preparedEvent) {\n    return null;\n  }\n\n  // This normally happens in browser client \"_prepareEvent\"\n  // but since we do not use this private method from the client, but rather the plain import\n  // we need to do this manually.\n  preparedEvent.platform = preparedEvent.platform || 'javascript';\n\n  // extract the SDK name because `client._prepareEvent` doesn't add it to the event\n  const metadata = client.getSdkMetadata && client.getSdkMetadata();\n  const { name, version } = (metadata && metadata.sdk) || {};\n\n  preparedEvent.sdk = {\n    ...preparedEvent.sdk,\n    name: name || 'sentry.javascript.unknown',\n    version: version || '0.0.0',\n  };\n\n  return preparedEvent;\n}\n","import { getClient, getCurrentScope } from '@sentry/core';\nimport type { ReplayEvent, TransportMakeRequestResponse } from '@sentry/types';\nimport type { RateLimits } from '@sentry/utils';\nimport { isRateLimited, updateRateLimits } from '@sentry/utils';\n\nimport { REPLAY_EVENT_NAME, UNABLE_TO_SEND_REPLAY } from '../constants';\nimport type { SendReplayData } from '../types';\nimport { createReplayEnvelope } from './createReplayEnvelope';\nimport { logInfo } from './log';\nimport { prepareRecordingData } from './prepareRecordingData';\nimport { prepareReplayEvent } from './prepareReplayEvent';\n\n/**\n * Send replay attachment using `fetch()`\n */\nexport async function sendReplayRequest({\n  recordingData,\n  replayId,\n  segmentId: segment_id,\n  eventContext,\n  timestamp,\n  session,\n}: SendReplayData): Promise<void | TransportMakeRequestResponse> {\n  const preparedRecordingData = prepareRecordingData({\n    recordingData,\n    headers: {\n      segment_id,\n    },\n  });\n\n  const { urls, errorIds, traceIds, initialTimestamp } = eventContext;\n\n  const client = getClient();\n  const scope = getCurrentScope();\n  const transport = client && client.getTransport();\n  const dsn = client && client.getDsn();\n\n  if (!client || !transport || !dsn || !session.sampled) {\n    return;\n  }\n\n  const baseEvent: ReplayEvent = {\n    type: REPLAY_EVENT_NAME,\n    replay_start_timestamp: initialTimestamp / 1000,\n    timestamp: timestamp / 1000,\n    error_ids: errorIds,\n    trace_ids: traceIds,\n    urls,\n    replay_id: replayId,\n    segment_id,\n    replay_type: session.sampled,\n  };\n\n  const replayEvent = await prepareReplayEvent({ scope, client, replayId, event: baseEvent });\n\n  if (!replayEvent) {\n    // Taken from baseclient's `_processEvent` method, where this is handled for errors/transactions\n    client.recordDroppedEvent('event_processor', 'replay', baseEvent);\n    logInfo('An event processor returned `null`, will not send event.');\n    return;\n  }\n\n  /*\n  For reference, the fully built event looks something like this:\n  {\n      \"type\": \"replay_event\",\n      \"timestamp\": 1670837008.634,\n      \"error_ids\": [\n          \"errorId\"\n      ],\n      \"trace_ids\": [\n          \"traceId\"\n      ],\n      \"urls\": [\n          \"https://example.com\"\n      ],\n      \"replay_id\": \"eventId\",\n      \"segment_id\": 3,\n      \"replay_type\": \"error\",\n      \"platform\": \"javascript\",\n      \"event_id\": \"eventId\",\n      \"environment\": \"production\",\n      \"sdk\": {\n          \"integrations\": [\n              \"BrowserTracing\",\n              \"Replay\"\n          ],\n          \"name\": \"sentry.javascript.browser\",\n          \"version\": \"7.25.0\"\n      },\n      \"sdkProcessingMetadata\": {},\n      \"contexts\": {\n      },\n  }\n  */\n\n  // Prevent this data (which, if it exists, was used in earlier steps in the processing pipeline) from being sent to\n  // sentry. (Note: Our use of this property comes and goes with whatever we might be debugging, whatever hacks we may\n  // have temporarily added, etc. Even if we don't happen to be using it at some point in the future, let's not get rid\n  // of this `delete`, lest we miss putting it back in the next time the property is in use.)\n  delete replayEvent.sdkProcessingMetadata;\n\n  const envelope = createReplayEnvelope(replayEvent, preparedRecordingData, dsn, client.getOptions().tunnel);\n\n  let response: void | TransportMakeRequestResponse;\n\n  try {\n    response = await transport.send(envelope);\n  } catch (err) {\n    const error = new Error(UNABLE_TO_SEND_REPLAY);\n\n    try {\n      // In case browsers don't allow this property to be writable\n      // @ts-expect-error This needs lib es2022 and newer\n      error.cause = err;\n    } catch {\n      // nothing to do\n    }\n    throw error;\n  }\n\n  // TODO (v8): we can remove this guard once transport.send's type signature doesn't include void anymore\n  if (!response) {\n    return response;\n  }\n\n  // If the status code is invalid, we want to immediately stop & not retry\n  if (typeof response.statusCode === 'number' && (response.statusCode < 200 || response.statusCode >= 300)) {\n    throw new TransportStatusCodeError(response.statusCode);\n  }\n\n  const rateLimits = updateRateLimits({}, response);\n  if (isRateLimited(rateLimits, 'replay')) {\n    throw new RateLimitError(rateLimits);\n  }\n\n  return response;\n}\n\n/**\n * This error indicates that the transport returned an invalid status code.\n */\nexport class TransportStatusCodeError extends Error {\n  public constructor(statusCode: number) {\n    super(`Transport returned status code ${statusCode}`);\n  }\n}\n\n/**\n * This error indicates that we hit a rate limit API error.\n */\nexport class RateLimitError extends Error {\n  public rateLimits: RateLimits;\n\n  public constructor(rateLimits: RateLimits) {\n    super('Rate limit hit');\n    this.rateLimits = rateLimits;\n  }\n}\n","import { captureException, setContext } from '@sentry/core';\n\nimport { RETRY_BASE_INTERVAL, RETRY_MAX_COUNT, UNABLE_TO_SEND_REPLAY } from '../constants';\nimport { DEBUG_BUILD } from '../debug-build';\nimport type { SendReplayData } from '../types';\nimport { RateLimitError, TransportStatusCodeError, sendReplayRequest } from './sendReplayRequest';\n\n/**\n * Finalize and send the current replay event to Sentry\n */\nexport async function sendReplay(\n  replayData: SendReplayData,\n  retryConfig = {\n    count: 0,\n    interval: RETRY_BASE_INTERVAL,\n  },\n): Promise<unknown> {\n  const { recordingData, options } = replayData;\n\n  // short circuit if there's no events to upload (this shouldn't happen as _runFlush makes this check)\n  if (!recordingData.length) {\n    return;\n  }\n\n  try {\n    await sendReplayRequest(replayData);\n    return true;\n  } catch (err) {\n    if (err instanceof TransportStatusCodeError || err instanceof RateLimitError) {\n      throw err;\n    }\n\n    // Capture error for every failed replay\n    setContext('Replays', {\n      _retryCount: retryConfig.count,\n    });\n\n    if (DEBUG_BUILD && options._experiments && options._experiments.captureExceptions) {\n      captureException(err);\n    }\n\n    // If an error happened here, it's likely that uploading the attachment\n    // failed, we'll can retry with the same events payload\n    if (retryConfig.count >= RETRY_MAX_COUNT) {\n      const error = new Error(`${UNABLE_TO_SEND_REPLAY} - max retries exceeded`);\n\n      try {\n        // In case browsers don't allow this property to be writable\n        // @ts-expect-error This needs lib es2022 and newer\n        error.cause = err;\n      } catch {\n        // nothing to do\n      }\n\n      throw error;\n    }\n\n    // will retry in intervals of 5, 10, 30\n    retryConfig.interval *= ++retryConfig.count;\n\n    return new Promise((resolve, reject) => {\n      setTimeout(async () => {\n        try {\n          await sendReplay(replayData, retryConfig);\n          resolve(true);\n        } catch (err) {\n          reject(err);\n        }\n      }, retryConfig.interval);\n    });\n  }\n}\n","export const THROTTLED = '__THROTTLED';\nexport const SKIPPED = '__SKIPPED';\n\n/**\n * Create a throttled function off a given function.\n * When calling the throttled function, it will call the original function only\n * if it hasn't been called more than `maxCount` times in the last `durationSeconds`.\n *\n * Returns `THROTTLED` if throttled for the first time, after that `SKIPPED`,\n * or else the return value of the original function.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function throttle<T extends (...rest: any[]) => any>(\n  fn: T,\n  maxCount: number,\n  durationSeconds: number,\n): (...rest: Parameters<T>) => ReturnType<T> | typeof THROTTLED | typeof SKIPPED {\n  const counter = new Map<number, number>();\n\n  const _cleanup = (now: number): void => {\n    const threshold = now - durationSeconds;\n    counter.forEach((_value, key) => {\n      if (key < threshold) {\n        counter.delete(key);\n      }\n    });\n  };\n\n  const _getTotalCount = (): number => {\n    return [...counter.values()].reduce((a, b) => a + b, 0);\n  };\n\n  let isThrottled = false;\n\n  return (...rest: Parameters<T>): ReturnType<T> | typeof THROTTLED | typeof SKIPPED => {\n    // Date in second-precision, which we use as basis for the throttling\n    const now = Math.floor(Date.now() / 1000);\n\n    // First, make sure to delete any old entries\n    _cleanup(now);\n\n    // If already over limit, do nothing\n    if (_getTotalCount() >= maxCount) {\n      const wasThrottled = isThrottled;\n      isThrottled = true;\n      return wasThrottled ? SKIPPED : THROTTLED;\n    }\n\n    isThrottled = false;\n    const count = counter.get(now) || 0;\n    counter.set(now, count + 1);\n\n    return fn(...rest);\n  };\n}\n","/* eslint-disable max-lines */ // TODO: We might want to split this file up\nimport { EventType, record } from '@sentry-internal/rrweb';\nimport {\n  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,\n  captureException,\n  getClient,\n  getCurrentScope,\n  spanToJSON,\n} from '@sentry/core';\nimport type { ReplayRecordingMode, Transaction } from '@sentry/types';\nimport { logger } from '@sentry/utils';\n\nimport {\n  BUFFER_CHECKOUT_TIME,\n  SESSION_IDLE_EXPIRE_DURATION,\n  SESSION_IDLE_PAUSE_DURATION,\n  SLOW_CLICK_SCROLL_TIMEOUT,\n  SLOW_CLICK_THRESHOLD,\n  WINDOW,\n} from './constants';\nimport { ClickDetector } from './coreHandlers/handleClick';\nimport { handleKeyboardEvent } from './coreHandlers/handleKeyboardEvent';\nimport { setupPerformanceObserver } from './coreHandlers/performanceObserver';\nimport { DEBUG_BUILD } from './debug-build';\nimport { createEventBuffer } from './eventBuffer';\nimport { clearSession } from './session/clearSession';\nimport { loadOrCreateSession } from './session/loadOrCreateSession';\nimport { saveSession } from './session/saveSession';\nimport { shouldRefreshSession } from './session/shouldRefreshSession';\n\nimport type {\n  AddEventResult,\n  AddUpdateCallback,\n  AllPerformanceEntry,\n  AllPerformanceEntryData,\n  EventBuffer,\n  InternalEventContext,\n  PopEventContext,\n  RecordingEvent,\n  RecordingOptions,\n  ReplayBreadcrumbFrame,\n  ReplayCanvasIntegrationOptions,\n  ReplayContainer as ReplayContainerInterface,\n  ReplayPerformanceEntry,\n  ReplayPluginOptions,\n  SendBufferedReplayOptions,\n  Session,\n  SlowClickConfig,\n  Timeouts,\n} from './types';\nimport { ReplayEventTypeCustom } from './types';\nimport { addEvent, addEventSync } from './util/addEvent';\nimport { addGlobalListeners } from './util/addGlobalListeners';\nimport { addMemoryEntry } from './util/addMemoryEntry';\nimport { createBreadcrumb } from './util/createBreadcrumb';\nimport { createPerformanceEntries } from './util/createPerformanceEntries';\nimport { createPerformanceSpans } from './util/createPerformanceSpans';\nimport { debounce } from './util/debounce';\nimport { getHandleRecordingEmit } from './util/handleRecordingEmit';\nimport { isExpired } from './util/isExpired';\nimport { isSessionExpired } from './util/isSessionExpired';\nimport { logInfo, logInfoNextTick } from './util/log';\nimport { sendReplay } from './util/sendReplay';\nimport type { SKIPPED } from './util/throttle';\nimport { THROTTLED, throttle } from './util/throttle';\n\n/**\n * The main replay container class, which holds all the state and methods for recording and sending replays.\n */\nexport class ReplayContainer implements ReplayContainerInterface {\n  public eventBuffer: EventBuffer | null;\n\n  public performanceEntries: AllPerformanceEntry[];\n\n  public replayPerformanceEntries: ReplayPerformanceEntry<AllPerformanceEntryData>[];\n\n  public session: Session | undefined;\n\n  public clickDetector: ClickDetector | undefined;\n\n  /**\n   * Recording can happen in one of three modes:\n   *   - session: Record the whole session, sending it continuously\n   *   - buffer: Always keep the last 60s of recording, requires:\n   *     - having replaysOnErrorSampleRate > 0 to capture replay when an error occurs\n   *     - or calling `flush()` to send the replay\n   */\n  public recordingMode: ReplayRecordingMode;\n\n  /**\n   * The current or last active transcation.\n   * This is only available when performance is enabled.\n   */\n  public lastTransaction?: Transaction;\n\n  /**\n   * These are here so we can overwrite them in tests etc.\n   * @hidden\n   */\n  public readonly timeouts: Timeouts;\n\n  private _throttledAddEvent: (\n    event: RecordingEvent,\n    isCheckout?: boolean,\n  ) => typeof THROTTLED | typeof SKIPPED | Promise<AddEventResult | null>;\n\n  /**\n   * Options to pass to `rrweb.record()`\n   */\n  private readonly _recordingOptions: RecordingOptions;\n\n  private readonly _options: ReplayPluginOptions;\n\n  private _performanceCleanupCallback?: () => void;\n\n  private _debouncedFlush: ReturnType<typeof debounce>;\n  private _flushLock: Promise<unknown> | undefined;\n\n  /**\n   * Timestamp of the last user activity. This lives across sessions.\n   */\n  private _lastActivity: number;\n\n  /**\n   * Is the integration currently active?\n   */\n  private _isEnabled: boolean;\n\n  /**\n   * Paused is a state where:\n   * - DOM Recording is not listening at all\n   * - Nothing will be added to event buffer (e.g. core SDK events)\n   */\n  private _isPaused: boolean;\n\n  /**\n   * Have we attached listeners to the core SDK?\n   * Note we have to track this as there is no way to remove instrumentation handlers.\n   */\n  private _hasInitializedCoreListeners: boolean;\n\n  /**\n   * Function to stop recording\n   */\n  private _stopRecording: ReturnType<typeof record> | undefined;\n\n  private _context: InternalEventContext;\n\n  /**\n   * Internal use for canvas recording options\n   */\n  private _canvas: ReplayCanvasIntegrationOptions | undefined;\n\n  public constructor({\n    options,\n    recordingOptions,\n  }: {\n    options: ReplayPluginOptions;\n    recordingOptions: RecordingOptions;\n  }) {\n    this.eventBuffer = null;\n    this.performanceEntries = [];\n    this.replayPerformanceEntries = [];\n    this.recordingMode = 'session';\n    this.timeouts = {\n      sessionIdlePause: SESSION_IDLE_PAUSE_DURATION,\n      sessionIdleExpire: SESSION_IDLE_EXPIRE_DURATION,\n    } as const;\n    this._lastActivity = Date.now();\n    this._isEnabled = false;\n    this._isPaused = false;\n    this._hasInitializedCoreListeners = false;\n    this._context = {\n      errorIds: new Set(),\n      traceIds: new Set(),\n      urls: [],\n      initialTimestamp: Date.now(),\n      initialUrl: '',\n    };\n\n    this._recordingOptions = recordingOptions;\n    this._options = options;\n\n    this._debouncedFlush = debounce(() => this._flush(), this._options.flushMinDelay, {\n      maxWait: this._options.flushMaxDelay,\n    });\n\n    this._throttledAddEvent = throttle(\n      (event: RecordingEvent, isCheckout?: boolean) => addEvent(this, event, isCheckout),\n      // Max 300 events...\n      300,\n      // ... per 5s\n      5,\n    );\n\n    const { slowClickTimeout, slowClickIgnoreSelectors } = this.getOptions();\n\n    const slowClickConfig: SlowClickConfig | undefined = slowClickTimeout\n      ? {\n          threshold: Math.min(SLOW_CLICK_THRESHOLD, slowClickTimeout),\n          timeout: slowClickTimeout,\n          scrollTimeout: SLOW_CLICK_SCROLL_TIMEOUT,\n          ignoreSelector: slowClickIgnoreSelectors ? slowClickIgnoreSelectors.join(',') : '',\n        }\n      : undefined;\n\n    if (slowClickConfig) {\n      this.clickDetector = new ClickDetector(this, slowClickConfig);\n    }\n  }\n\n  /** Get the event context. */\n  public getContext(): InternalEventContext {\n    return this._context;\n  }\n\n  /** If recording is currently enabled. */\n  public isEnabled(): boolean {\n    return this._isEnabled;\n  }\n\n  /** If recording is currently paused. */\n  public isPaused(): boolean {\n    return this._isPaused;\n  }\n\n  /**\n   * Determine if canvas recording is enabled\n   */\n  public isRecordingCanvas(): boolean {\n    return Boolean(this._canvas);\n  }\n\n  /** Get the replay integration options. */\n  public getOptions(): ReplayPluginOptions {\n    return this._options;\n  }\n\n  /**\n   * Initializes the plugin based on sampling configuration. Should not be\n   * called outside of constructor.\n   */\n  public initializeSampling(previousSessionId?: string): void {\n    const { errorSampleRate, sessionSampleRate } = this._options;\n\n    // If neither sample rate is > 0, then do nothing - user will need to call one of\n    // `start()` or `startBuffering` themselves.\n    if (errorSampleRate <= 0 && sessionSampleRate <= 0) {\n      return;\n    }\n\n    // Otherwise if there is _any_ sample rate set, try to load an existing\n    // session, or create a new one.\n    this._initializeSessionForSampling(previousSessionId);\n\n    if (!this.session) {\n      // This should not happen, something wrong has occurred\n      this._handleException(new Error('Unable to initialize and create session'));\n      return;\n    }\n\n    if (this.session.sampled === false) {\n      // This should only occur if `errorSampleRate` is 0 and was unsampled for\n      // session-based replay. In this case there is nothing to do.\n      return;\n    }\n\n    // If segmentId > 0, it means we've previously already captured this session\n    // In this case, we still want to continue in `session` recording mode\n    this.recordingMode = this.session.sampled === 'buffer' && this.session.segmentId === 0 ? 'buffer' : 'session';\n\n    logInfoNextTick(\n      `[Replay] Starting replay in ${this.recordingMode} mode`,\n      this._options._experiments.traceInternals,\n    );\n\n    this._initializeRecording();\n  }\n\n  /**\n   * Start a replay regardless of sampling rate. Calling this will always\n   * create a new session. Will throw an error if replay is already in progress.\n   *\n   * Creates or loads a session, attaches listeners to varying events (DOM,\n   * _performanceObserver, Recording, Sentry SDK, etc)\n   */\n  public start(): void {\n    if (this._isEnabled && this.recordingMode === 'session') {\n      throw new Error('Replay recording is already in progress');\n    }\n\n    if (this._isEnabled && this.recordingMode === 'buffer') {\n      throw new Error('Replay buffering is in progress, call `flush()` to save the replay');\n    }\n\n    logInfoNextTick('[Replay] Starting replay in session mode', this._options._experiments.traceInternals);\n\n    // Required as user activity is initially set in\n    // constructor, so if `start()` is called after\n    // session idle expiration, a replay will not be\n    // created due to an idle timeout.\n    this._updateUserActivity();\n\n    const session = loadOrCreateSession(\n      {\n        maxReplayDuration: this._options.maxReplayDuration,\n        sessionIdleExpire: this.timeouts.sessionIdleExpire,\n        traceInternals: this._options._experiments.traceInternals,\n      },\n      {\n        stickySession: this._options.stickySession,\n        // This is intentional: create a new session-based replay when calling `start()`\n        sessionSampleRate: 1,\n        allowBuffering: false,\n      },\n    );\n\n    this.session = session;\n\n    this._initializeRecording();\n  }\n\n  /**\n   * Start replay buffering. Buffers until `flush()` is called or, if\n   * `replaysOnErrorSampleRate` > 0, an error occurs.\n   */\n  public startBuffering(): void {\n    if (this._isEnabled) {\n      throw new Error('Replay recording is already in progress');\n    }\n\n    logInfoNextTick('[Replay] Starting replay in buffer mode', this._options._experiments.traceInternals);\n\n    const session = loadOrCreateSession(\n      {\n        sessionIdleExpire: this.timeouts.sessionIdleExpire,\n        maxReplayDuration: this._options.maxReplayDuration,\n        traceInternals: this._options._experiments.traceInternals,\n      },\n      {\n        stickySession: this._options.stickySession,\n        sessionSampleRate: 0,\n        allowBuffering: true,\n      },\n    );\n\n    this.session = session;\n\n    this.recordingMode = 'buffer';\n    this._initializeRecording();\n  }\n\n  /**\n   * Start recording.\n   *\n   * Note that this will cause a new DOM checkout\n   */\n  public startRecording(): void {\n    try {\n      const canvasOptions = this._canvas;\n\n      this._stopRecording = record({\n        ...this._recordingOptions,\n        // When running in error sampling mode, we need to overwrite `checkoutEveryNms`\n        // Without this, it would record forever, until an error happens, which we don't want\n        // instead, we'll always keep the last 60 seconds of replay before an error happened\n        ...(this.recordingMode === 'buffer' && { checkoutEveryNms: BUFFER_CHECKOUT_TIME }),\n        emit: getHandleRecordingEmit(this),\n        onMutation: this._onMutationHandler,\n        ...(canvasOptions\n          ? {\n              recordCanvas: canvasOptions.recordCanvas,\n              getCanvasManager: canvasOptions.getCanvasManager,\n              sampling: canvasOptions.sampling,\n              dataURLOptions: canvasOptions.dataURLOptions,\n            }\n          : {}),\n      });\n    } catch (err) {\n      this._handleException(err);\n    }\n  }\n\n  /**\n   * Stops the recording, if it was running.\n   *\n   * Returns true if it was previously stopped, or is now stopped,\n   * otherwise false.\n   */\n  public stopRecording(): boolean {\n    try {\n      if (this._stopRecording) {\n        this._stopRecording();\n        this._stopRecording = undefined;\n      }\n\n      return true;\n    } catch (err) {\n      this._handleException(err);\n      return false;\n    }\n  }\n\n  /**\n   * Currently, this needs to be manually called (e.g. for tests). Sentry SDK\n   * does not support a teardown\n   */\n  public async stop({ forceFlush = false, reason }: { forceFlush?: boolean; reason?: string } = {}): Promise<void> {\n    if (!this._isEnabled) {\n      return;\n    }\n\n    // We can't move `_isEnabled` after awaiting a flush, otherwise we can\n    // enter into an infinite loop when `stop()` is called while flushing.\n    this._isEnabled = false;\n\n    try {\n      logInfo(\n        `[Replay] Stopping Replay${reason ? ` triggered by ${reason}` : ''}`,\n        this._options._experiments.traceInternals,\n      );\n\n      this._removeListeners();\n      this.stopRecording();\n\n      this._debouncedFlush.cancel();\n      // See comment above re: `_isEnabled`, we \"force\" a flush, ignoring the\n      // `_isEnabled` state of the plugin since it was disabled above.\n      if (forceFlush) {\n        await this._flush({ force: true });\n      }\n\n      // After flush, destroy event buffer\n      this.eventBuffer && this.eventBuffer.destroy();\n      this.eventBuffer = null;\n\n      // Clear session from session storage, note this means if a new session\n      // is started after, it will not have `previousSessionId`\n      clearSession(this);\n    } catch (err) {\n      this._handleException(err);\n    }\n  }\n\n  /**\n   * Pause some replay functionality. See comments for `_isPaused`.\n   * This differs from stop as this only stops DOM recording, it is\n   * not as thorough of a shutdown as `stop()`.\n   */\n  public pause(): void {\n    if (this._isPaused) {\n      return;\n    }\n\n    this._isPaused = true;\n    this.stopRecording();\n\n    logInfo('[Replay] Pausing replay', this._options._experiments.traceInternals);\n  }\n\n  /**\n   * Resumes recording, see notes for `pause().\n   *\n   * Note that calling `startRecording()` here will cause a\n   * new DOM checkout.`\n   */\n  public resume(): void {\n    if (!this._isPaused || !this._checkSession()) {\n      return;\n    }\n\n    this._isPaused = false;\n    this.startRecording();\n\n    logInfo('[Replay] Resuming replay', this._options._experiments.traceInternals);\n  }\n\n  /**\n   * If not in \"session\" recording mode, flush event buffer which will create a new replay.\n   * Unless `continueRecording` is false, the replay will continue to record and\n   * behave as a \"session\"-based replay.\n   *\n   * Otherwise, queue up a flush.\n   */\n  public async sendBufferedReplayOrFlush({ continueRecording = true }: SendBufferedReplayOptions = {}): Promise<void> {\n    if (this.recordingMode === 'session') {\n      return this.flushImmediate();\n    }\n\n    const activityTime = Date.now();\n\n    logInfo('[Replay] Converting buffer to session', this._options._experiments.traceInternals);\n\n    // Allow flush to complete before resuming as a session recording, otherwise\n    // the checkout from `startRecording` may be included in the payload.\n    // Prefer to keep the error replay as a separate (and smaller) segment\n    // than the session replay.\n    await this.flushImmediate();\n\n    const hasStoppedRecording = this.stopRecording();\n\n    if (!continueRecording || !hasStoppedRecording) {\n      return;\n    }\n\n    // To avoid race conditions where this is called multiple times, we check here again that we are still buffering\n    if ((this.recordingMode as ReplayRecordingMode) === 'session') {\n      return;\n    }\n\n    // Re-start recording in session-mode\n    this.recordingMode = 'session';\n\n    // Once this session ends, we do not want to refresh it\n    if (this.session) {\n      this._updateUserActivity(activityTime);\n      this._updateSessionActivity(activityTime);\n      this._maybeSaveSession();\n    }\n\n    this.startRecording();\n  }\n\n  /**\n   * We want to batch uploads of replay events. Save events only if\n   * `<flushMinDelay>` milliseconds have elapsed since the last event\n   * *OR* if `<flushMaxDelay>` milliseconds have elapsed.\n   *\n   * Accepts a callback to perform side-effects and returns true to stop batch\n   * processing and hand back control to caller.\n   */\n  public addUpdate(cb: AddUpdateCallback): void {\n    // We need to always run `cb` (e.g. in the case of `this.recordingMode == 'buffer'`)\n    const cbResult = cb();\n\n    // If this option is turned on then we will only want to call `flush`\n    // explicitly\n    if (this.recordingMode === 'buffer') {\n      return;\n    }\n\n    // If callback is true, we do not want to continue with flushing -- the\n    // caller will need to handle it.\n    if (cbResult === true) {\n      return;\n    }\n\n    // addUpdate is called quite frequently - use _debouncedFlush so that it\n    // respects the flush delays and does not flush immediately\n    this._debouncedFlush();\n  }\n\n  /**\n   * Updates the user activity timestamp and resumes recording. This should be\n   * called in an event handler for a user action that we consider as the user\n   * being \"active\" (e.g. a mouse click).\n   */\n  public triggerUserActivity(): void {\n    this._updateUserActivity();\n\n    // This case means that recording was once stopped due to inactivity.\n    // Ensure that recording is resumed.\n    if (!this._stopRecording) {\n      // Create a new session, otherwise when the user action is flushed, it\n      // will get rejected due to an expired session.\n      if (!this._checkSession()) {\n        return;\n      }\n\n      // Note: This will cause a new DOM checkout\n      this.resume();\n      return;\n    }\n\n    // Otherwise... recording was never suspended, continue as normalish\n    this.checkAndHandleExpiredSession();\n\n    this._updateSessionActivity();\n  }\n\n  /**\n   * Updates the user activity timestamp *without* resuming\n   * recording. Some user events (e.g. keydown) can be create\n   * low-value replays that only contain the keypress as a\n   * breadcrumb. Instead this would require other events to\n   * create a new replay after a session has expired.\n   */\n  public updateUserActivity(): void {\n    this._updateUserActivity();\n    this._updateSessionActivity();\n  }\n\n  /**\n   * Only flush if `this.recordingMode === 'session'`\n   */\n  public conditionalFlush(): Promise<void> {\n    if (this.recordingMode === 'buffer') {\n      return Promise.resolve();\n    }\n\n    return this.flushImmediate();\n  }\n\n  /**\n   * Flush using debounce flush\n   */\n  public flush(): Promise<void> {\n    return this._debouncedFlush() as Promise<void>;\n  }\n\n  /**\n   * Always flush via `_debouncedFlush` so that we do not have flushes triggered\n   * from calling both `flush` and `_debouncedFlush`. Otherwise, there could be\n   * cases of mulitple flushes happening closely together.\n   */\n  public flushImmediate(): Promise<void> {\n    this._debouncedFlush();\n    // `.flush` is provided by the debounced function, analogously to lodash.debounce\n    return this._debouncedFlush.flush() as Promise<void>;\n  }\n\n  /**\n   * Cancels queued up flushes.\n   */\n  public cancelFlush(): void {\n    this._debouncedFlush.cancel();\n  }\n\n  /** Get the current sesion (=replay) ID */\n  public getSessionId(): string | undefined {\n    return this.session && this.session.id;\n  }\n\n  /**\n   * Checks if recording should be stopped due to user inactivity. Otherwise\n   * check if session is expired and create a new session if so. Triggers a new\n   * full snapshot on new session.\n   *\n   * Returns true if session is not expired, false otherwise.\n   * @hidden\n   */\n  public checkAndHandleExpiredSession(): boolean | void {\n    // Prevent starting a new session if the last user activity is older than\n    // SESSION_IDLE_PAUSE_DURATION. Otherwise non-user activity can trigger a new\n    // session+recording. This creates noisy replays that do not have much\n    // content in them.\n    if (\n      this._lastActivity &&\n      isExpired(this._lastActivity, this.timeouts.sessionIdlePause) &&\n      this.session &&\n      this.session.sampled === 'session'\n    ) {\n      // Pause recording only for session-based replays. Otherwise, resuming\n      // will create a new replay and will conflict with users who only choose\n      // to record error-based replays only. (e.g. the resumed replay will not\n      // contain a reference to an error)\n      this.pause();\n      return;\n    }\n\n    // --- There is recent user activity --- //\n    // This will create a new session if expired, based on expiry length\n    if (!this._checkSession()) {\n      // Check session handles the refreshing itself\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Capture some initial state that can change throughout the lifespan of the\n   * replay. This is required because otherwise they would be captured at the\n   * first flush.\n   */\n  public setInitialState(): void {\n    const urlPath = `${WINDOW.location.pathname}${WINDOW.location.hash}${WINDOW.location.search}`;\n    const url = `${WINDOW.location.origin}${urlPath}`;\n\n    this.performanceEntries = [];\n    this.replayPerformanceEntries = [];\n\n    // Reset _context as well\n    this._clearContext();\n\n    this._context.initialUrl = url;\n    this._context.initialTimestamp = Date.now();\n    this._context.urls.push(url);\n  }\n\n  /**\n   * Add a breadcrumb event, that may be throttled.\n   * If it was throttled, we add a custom breadcrumb to indicate that.\n   */\n  public throttledAddEvent(\n    event: RecordingEvent,\n    isCheckout?: boolean,\n  ): typeof THROTTLED | typeof SKIPPED | Promise<AddEventResult | null> {\n    const res = this._throttledAddEvent(event, isCheckout);\n\n    // If this is THROTTLED, it means we have throttled the event for the first time\n    // In this case, we want to add a breadcrumb indicating that something was skipped\n    if (res === THROTTLED) {\n      const breadcrumb = createBreadcrumb({\n        category: 'replay.throttled',\n      });\n\n      this.addUpdate(() => {\n        // Return `false` if the event _was_ added, as that means we schedule a flush\n        return !addEventSync(this, {\n          type: ReplayEventTypeCustom,\n          timestamp: breadcrumb.timestamp || 0,\n          data: {\n            tag: 'breadcrumb',\n            payload: breadcrumb,\n            metric: true,\n          },\n        });\n      });\n    }\n\n    return res;\n  }\n\n  /**\n   * This will get the parametrized route name of the current page.\n   * This is only available if performance is enabled, and if an instrumented router is used.\n   */\n  public getCurrentRoute(): string | undefined {\n    // eslint-disable-next-line deprecation/deprecation\n    const lastTransaction = this.lastTransaction || getCurrentScope().getTransaction();\n\n    const attributes = (lastTransaction && spanToJSON(lastTransaction).data) || {};\n    const source = attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];\n    if (!lastTransaction || !source || !['route', 'custom'].includes(source)) {\n      return undefined;\n    }\n\n    return spanToJSON(lastTransaction).description;\n  }\n\n  /**\n   * Initialize and start all listeners to varying events (DOM,\n   * Performance Observer, Recording, Sentry SDK, etc)\n   */\n  private _initializeRecording(): void {\n    this.setInitialState();\n\n    // this method is generally called on page load or manually - in both cases\n    // we should treat it as an activity\n    this._updateSessionActivity();\n\n    this.eventBuffer = createEventBuffer({\n      useCompression: this._options.useCompression,\n      workerUrl: this._options.workerUrl,\n    });\n\n    this._removeListeners();\n    this._addListeners();\n\n    // Need to set as enabled before we start recording, as `record()` can trigger a flush with a new checkout\n    this._isEnabled = true;\n    this._isPaused = false;\n\n    this.startRecording();\n  }\n\n  /** A wrapper to conditionally capture exceptions. */\n  private _handleException(error: unknown): void {\n    DEBUG_BUILD && logger.error('[Replay]', error);\n\n    if (DEBUG_BUILD && this._options._experiments && this._options._experiments.captureExceptions) {\n      captureException(error);\n    }\n  }\n\n  /**\n   * Loads (or refreshes) the current session.\n   */\n  private _initializeSessionForSampling(previousSessionId?: string): void {\n    // Whenever there is _any_ error sample rate, we always allow buffering\n    // Because we decide on sampling when an error occurs, we need to buffer at all times if sampling for errors\n    const allowBuffering = this._options.errorSampleRate > 0;\n\n    const session = loadOrCreateSession(\n      {\n        sessionIdleExpire: this.timeouts.sessionIdleExpire,\n        maxReplayDuration: this._options.maxReplayDuration,\n        traceInternals: this._options._experiments.traceInternals,\n        previousSessionId,\n      },\n      {\n        stickySession: this._options.stickySession,\n        sessionSampleRate: this._options.sessionSampleRate,\n        allowBuffering,\n      },\n    );\n\n    this.session = session;\n  }\n\n  /**\n   * Checks and potentially refreshes the current session.\n   * Returns false if session is not recorded.\n   */\n  private _checkSession(): boolean {\n    // If there is no session yet, we do not want to refresh anything\n    // This should generally not happen, but to be safe....\n    if (!this.session) {\n      return false;\n    }\n\n    const currentSession = this.session;\n\n    if (\n      shouldRefreshSession(currentSession, {\n        sessionIdleExpire: this.timeouts.sessionIdleExpire,\n        maxReplayDuration: this._options.maxReplayDuration,\n      })\n    ) {\n      // This should never reject\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      this._refreshSession(currentSession);\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Refresh a session with a new one.\n   * This stops the current session (without forcing a flush, as that would never work since we are expired),\n   * and then does a new sampling based on the refreshed session.\n   */\n  private async _refreshSession(session: Session): Promise<void> {\n    if (!this._isEnabled) {\n      return;\n    }\n    await this.stop({ reason: 'refresh session' });\n    this.initializeSampling(session.id);\n  }\n\n  /**\n   * Adds listeners to record events for the replay\n   */\n  private _addListeners(): void {\n    try {\n      WINDOW.document.addEventListener('visibilitychange', this._handleVisibilityChange);\n      WINDOW.addEventListener('blur', this._handleWindowBlur);\n      WINDOW.addEventListener('focus', this._handleWindowFocus);\n      WINDOW.addEventListener('keydown', this._handleKeyboardEvent);\n\n      if (this.clickDetector) {\n        this.clickDetector.addListeners();\n      }\n\n      // There is no way to remove these listeners, so ensure they are only added once\n      if (!this._hasInitializedCoreListeners) {\n        addGlobalListeners(this);\n\n        this._hasInitializedCoreListeners = true;\n      }\n    } catch (err) {\n      this._handleException(err);\n    }\n\n    this._performanceCleanupCallback = setupPerformanceObserver(this);\n  }\n\n  /**\n   * Cleans up listeners that were created in `_addListeners`\n   */\n  private _removeListeners(): void {\n    try {\n      WINDOW.document.removeEventListener('visibilitychange', this._handleVisibilityChange);\n\n      WINDOW.removeEventListener('blur', this._handleWindowBlur);\n      WINDOW.removeEventListener('focus', this._handleWindowFocus);\n      WINDOW.removeEventListener('keydown', this._handleKeyboardEvent);\n\n      if (this.clickDetector) {\n        this.clickDetector.removeListeners();\n      }\n\n      if (this._performanceCleanupCallback) {\n        this._performanceCleanupCallback();\n      }\n    } catch (err) {\n      this._handleException(err);\n    }\n  }\n\n  /**\n   * Handle when visibility of the page content changes. Opening a new tab will\n   * cause the state to change to hidden because of content of current page will\n   * be hidden. Likewise, moving a different window to cover the contents of the\n   * page will also trigger a change to a hidden state.\n   */\n  private _handleVisibilityChange: () => void = () => {\n    if (WINDOW.document.visibilityState === 'visible') {\n      this._doChangeToForegroundTasks();\n    } else {\n      this._doChangeToBackgroundTasks();\n    }\n  };\n\n  /**\n   * Handle when page is blurred\n   */\n  private _handleWindowBlur: () => void = () => {\n    const breadcrumb = createBreadcrumb({\n      category: 'ui.blur',\n    });\n\n    // Do not count blur as a user action -- it's part of the process of them\n    // leaving the page\n    this._doChangeToBackgroundTasks(breadcrumb);\n  };\n\n  /**\n   * Handle when page is focused\n   */\n  private _handleWindowFocus: () => void = () => {\n    const breadcrumb = createBreadcrumb({\n      category: 'ui.focus',\n    });\n\n    // Do not count focus as a user action -- instead wait until they focus and\n    // interactive with page\n    this._doChangeToForegroundTasks(breadcrumb);\n  };\n\n  /** Ensure page remains active when a key is pressed. */\n  private _handleKeyboardEvent: (event: KeyboardEvent) => void = (event: KeyboardEvent) => {\n    handleKeyboardEvent(this, event);\n  };\n\n  /**\n   * Tasks to run when we consider a page to be hidden (via blurring and/or visibility)\n   */\n  private _doChangeToBackgroundTasks(breadcrumb?: ReplayBreadcrumbFrame): void {\n    if (!this.session) {\n      return;\n    }\n\n    const expired = isSessionExpired(this.session, {\n      maxReplayDuration: this._options.maxReplayDuration,\n      sessionIdleExpire: this.timeouts.sessionIdleExpire,\n    });\n\n    if (expired) {\n      return;\n    }\n\n    if (breadcrumb) {\n      this._createCustomBreadcrumb(breadcrumb);\n    }\n\n    // Send replay when the page/tab becomes hidden. There is no reason to send\n    // replay if it becomes visible, since no actions we care about were done\n    // while it was hidden\n    // This should never reject\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    void this.conditionalFlush();\n  }\n\n  /**\n   * Tasks to run when we consider a page to be visible (via focus and/or visibility)\n   */\n  private _doChangeToForegroundTasks(breadcrumb?: ReplayBreadcrumbFrame): void {\n    if (!this.session) {\n      return;\n    }\n\n    const isSessionActive = this.checkAndHandleExpiredSession();\n\n    if (!isSessionActive) {\n      // If the user has come back to the page within SESSION_IDLE_PAUSE_DURATION\n      // ms, we will re-use the existing session, otherwise create a new\n      // session\n      logInfo('[Replay] Document has become active, but session has expired');\n      return;\n    }\n\n    if (breadcrumb) {\n      this._createCustomBreadcrumb(breadcrumb);\n    }\n  }\n\n  /**\n   * Update user activity (across session lifespans)\n   */\n  private _updateUserActivity(_lastActivity: number = Date.now()): void {\n    this._lastActivity = _lastActivity;\n  }\n\n  /**\n   * Updates the session's last activity timestamp\n   */\n  private _updateSessionActivity(_lastActivity: number = Date.now()): void {\n    if (this.session) {\n      this.session.lastActivity = _lastActivity;\n      this._maybeSaveSession();\n    }\n  }\n\n  /**\n   * Helper to create (and buffer) a replay breadcrumb from a core SDK breadcrumb\n   */\n  private _createCustomBreadcrumb(breadcrumb: ReplayBreadcrumbFrame): void {\n    this.addUpdate(() => {\n      // This should never reject\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      this.throttledAddEvent({\n        type: EventType.Custom,\n        timestamp: breadcrumb.timestamp || 0,\n        data: {\n          tag: 'breadcrumb',\n          payload: breadcrumb,\n        },\n      });\n    });\n  }\n\n  /**\n   * Observed performance events are added to `this.performanceEntries`. These\n   * are included in the replay event before it is finished and sent to Sentry.\n   */\n  private _addPerformanceEntries(): Promise<Array<AddEventResult | null>> {\n    const performanceEntries = createPerformanceEntries(this.performanceEntries).concat(this.replayPerformanceEntries);\n\n    this.performanceEntries = [];\n    this.replayPerformanceEntries = [];\n\n    return Promise.all(createPerformanceSpans(this, performanceEntries));\n  }\n\n  /**\n   * Clear _context\n   */\n  private _clearContext(): void {\n    // XXX: `initialTimestamp` and `initialUrl` do not get cleared\n    this._context.errorIds.clear();\n    this._context.traceIds.clear();\n    this._context.urls = [];\n  }\n\n  /** Update the initial timestamp based on the buffer content. */\n  private _updateInitialTimestampFromEventBuffer(): void {\n    const { session, eventBuffer } = this;\n    if (!session || !eventBuffer) {\n      return;\n    }\n\n    // we only ever update this on the initial segment\n    if (session.segmentId) {\n      return;\n    }\n\n    const earliestEvent = eventBuffer.getEarliestTimestamp();\n    if (earliestEvent && earliestEvent < this._context.initialTimestamp) {\n      this._context.initialTimestamp = earliestEvent;\n    }\n  }\n\n  /**\n   * Return and clear _context\n   */\n  private _popEventContext(): PopEventContext {\n    const _context = {\n      initialTimestamp: this._context.initialTimestamp,\n      initialUrl: this._context.initialUrl,\n      errorIds: Array.from(this._context.errorIds),\n      traceIds: Array.from(this._context.traceIds),\n      urls: this._context.urls,\n    };\n\n    this._clearContext();\n\n    return _context;\n  }\n\n  /**\n   * Flushes replay event buffer to Sentry.\n   *\n   * Performance events are only added right before flushing - this is\n   * due to the buffered performance observer events.\n   *\n   * Should never be called directly, only by `flush`\n   */\n  private async _runFlush(): Promise<void> {\n    const replayId = this.getSessionId();\n\n    if (!this.session || !this.eventBuffer || !replayId) {\n      DEBUG_BUILD && logger.error('[Replay] No session or eventBuffer found to flush.');\n      return;\n    }\n\n    await this._addPerformanceEntries();\n\n    // Check eventBuffer again, as it could have been stopped in the meanwhile\n    if (!this.eventBuffer || !this.eventBuffer.hasEvents) {\n      return;\n    }\n\n    // Only attach memory event if eventBuffer is not empty\n    await addMemoryEntry(this);\n\n    // Check eventBuffer again, as it could have been stopped in the meanwhile\n    if (!this.eventBuffer) {\n      return;\n    }\n\n    // if this changed in the meanwhile, e.g. because the session was refreshed or similar, we abort here\n    if (replayId !== this.getSessionId()) {\n      return;\n    }\n\n    try {\n      // This uses the data from the eventBuffer, so we need to call this before `finish()\n      this._updateInitialTimestampFromEventBuffer();\n\n      const timestamp = Date.now();\n\n      // Check total duration again, to avoid sending outdated stuff\n      // We leave 30s wiggle room to accomodate late flushing etc.\n      // This _could_ happen when the browser is suspended during flushing, in which case we just want to stop\n      if (timestamp - this._context.initialTimestamp > this._options.maxReplayDuration + 30_000) {\n        throw new Error('Session is too long, not sending replay');\n      }\n\n      const eventContext = this._popEventContext();\n      // Always increment segmentId regardless of outcome of sending replay\n      const segmentId = this.session.segmentId++;\n      this._maybeSaveSession();\n\n      // Note this empties the event buffer regardless of outcome of sending replay\n      const recordingData = await this.eventBuffer.finish();\n\n      await sendReplay({\n        replayId,\n        recordingData,\n        segmentId,\n        eventContext,\n        session: this.session,\n        options: this.getOptions(),\n        timestamp,\n      });\n    } catch (err) {\n      this._handleException(err);\n\n      // This means we retried 3 times and all of them failed,\n      // or we ran into a problem we don't want to retry, like rate limiting.\n      // In this case, we want to completely stop the replay - otherwise, we may get inconsistent segments\n      // This should never reject\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      this.stop({ reason: 'sendReplay' });\n\n      const client = getClient();\n\n      if (client) {\n        client.recordDroppedEvent('send_error', 'replay');\n      }\n    }\n  }\n\n  /**\n   * Flush recording data to Sentry. Creates a lock so that only a single flush\n   * can be active at a time. Do not call this directly.\n   */\n  private _flush = async ({\n    force = false,\n  }: {\n    /**\n     * If true, flush while ignoring the `_isEnabled` state of\n     * Replay integration. (By default, flush is noop if integration\n     * is stopped).\n     */\n    force?: boolean;\n  } = {}): Promise<void> => {\n    if (!this._isEnabled && !force) {\n      // This can happen if e.g. the replay was stopped because of exceeding the retry limit\n      return;\n    }\n\n    if (!this.checkAndHandleExpiredSession()) {\n      DEBUG_BUILD && logger.error('[Replay] Attempting to finish replay event after session expired.');\n      return;\n    }\n\n    if (!this.session) {\n      // should never happen, as we would have bailed out before\n      return;\n    }\n\n    const start = this.session.started;\n    const now = Date.now();\n    const duration = now - start;\n\n    // A flush is about to happen, cancel any queued flushes\n    this._debouncedFlush.cancel();\n\n    // If session is too short, or too long (allow some wiggle room over maxReplayDuration), do not send it\n    // This _should_ not happen, but it may happen if flush is triggered due to a page activity change or similar\n    const tooShort = duration < this._options.minReplayDuration;\n    const tooLong = duration > this._options.maxReplayDuration + 5_000;\n    if (tooShort || tooLong) {\n      logInfo(\n        `[Replay] Session duration (${Math.floor(duration / 1000)}s) is too ${\n          tooShort ? 'short' : 'long'\n        }, not sending replay.`,\n        this._options._experiments.traceInternals,\n      );\n\n      if (tooShort) {\n        this._debouncedFlush();\n      }\n      return;\n    }\n\n    const eventBuffer = this.eventBuffer;\n    if (eventBuffer && this.session.segmentId === 0 && !eventBuffer.hasCheckout) {\n      logInfo('[Replay] Flushing initial segment without checkout.', this._options._experiments.traceInternals);\n      // TODO FN: Evaluate if we want to stop here, or remove this again?\n    }\n\n    // this._flushLock acts as a lock so that future calls to `_flush()`\n    // will be blocked until this promise resolves\n    if (!this._flushLock) {\n      this._flushLock = this._runFlush();\n      await this._flushLock;\n      this._flushLock = undefined;\n      return;\n    }\n\n    // Wait for previous flush to finish, then call the debounced `_flush()`.\n    // It's possible there are other flush requests queued and waiting for it\n    // to resolve. We want to reduce all outstanding requests (as well as any\n    // new flush requests that occur within a second of the locked flush\n    // completing) into a single flush.\n\n    try {\n      await this._flushLock;\n    } catch (err) {\n      DEBUG_BUILD && logger.error(err);\n    } finally {\n      this._debouncedFlush();\n    }\n  };\n\n  /** Save the session, if it is sticky */\n  private _maybeSaveSession(): void {\n    if (this.session && this._options.stickySession) {\n      saveSession(this.session);\n    }\n  }\n\n  /** Handler for rrweb.record.onMutation */\n  private _onMutationHandler = (mutations: unknown[]): boolean => {\n    const count = mutations.length;\n\n    const mutationLimit = this._options.mutationLimit;\n    const mutationBreadcrumbLimit = this._options.mutationBreadcrumbLimit;\n    const overMutationLimit = mutationLimit && count > mutationLimit;\n\n    // Create a breadcrumb if a lot of mutations happen at the same time\n    // We can show this in the UI as an information with potential performance improvements\n    if (count > mutationBreadcrumbLimit || overMutationLimit) {\n      const breadcrumb = createBreadcrumb({\n        category: 'replay.mutations',\n        data: {\n          count,\n          limit: overMutationLimit,\n        },\n      });\n      this._createCustomBreadcrumb(breadcrumb);\n    }\n\n    // Stop replay if over the mutation limit\n    if (overMutationLimit) {\n      // This should never reject\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      this.stop({ reason: 'mutationLimit', forceFlush: this.recordingMode === 'session' });\n      return false;\n    }\n\n    // `true` means we use the regular mutation handling by rrweb\n    return true;\n  };\n}\n","type DebouncedCallback = {\n  (): void | unknown;\n  flush: () => void | unknown;\n  cancel: () => void;\n};\ntype CallbackFunction = () => unknown;\ntype DebounceOptions = { maxWait?: number };\n\n/**\n * Heavily simplified debounce function based on lodash.debounce.\n *\n * This function takes a callback function (@param fun) and delays its invocation\n * by @param wait milliseconds. Optionally, a maxWait can be specified in @param options,\n * which ensures that the callback is invoked at least once after the specified max. wait time.\n *\n * @param func the function whose invocation is to be debounced\n * @param wait the minimum time until the function is invoked after it was called once\n * @param options the options object, which can contain the `maxWait` property\n *\n * @returns the debounced version of the function, which needs to be called at least once to start the\n *          debouncing process. Subsequent calls will reset the debouncing timer and, in case @paramfunc\n *          was already invoked in the meantime, return @param func's return value.\n *          The debounced function has two additional properties:\n *          - `flush`: Invokes the debounced function immediately and returns its return value\n *          - `cancel`: Cancels the debouncing process and resets the debouncing timer\n */\nexport function debounce(func: CallbackFunction, wait: number, options?: DebounceOptions): DebouncedCallback {\n  let callbackReturnValue: unknown;\n\n  let timerId: ReturnType<typeof setTimeout> | undefined;\n  let maxTimerId: ReturnType<typeof setTimeout> | undefined;\n\n  const maxWait = options && options.maxWait ? Math.max(options.maxWait, wait) : 0;\n\n  function invokeFunc(): unknown {\n    cancelTimers();\n    callbackReturnValue = func();\n    return callbackReturnValue;\n  }\n\n  function cancelTimers(): void {\n    timerId !== undefined && clearTimeout(timerId);\n    maxTimerId !== undefined && clearTimeout(maxTimerId);\n    timerId = maxTimerId = undefined;\n  }\n\n  function flush(): unknown {\n    if (timerId !== undefined || maxTimerId !== undefined) {\n      return invokeFunc();\n    }\n    return callbackReturnValue;\n  }\n\n  function debounced(): unknown {\n    if (timerId) {\n      clearTimeout(timerId);\n    }\n    timerId = setTimeout(invokeFunc, wait);\n\n    if (maxWait && maxTimerId === undefined) {\n      maxTimerId = setTimeout(invokeFunc, maxWait);\n    }\n\n    return callbackReturnValue;\n  }\n\n  debounced.cancel = cancelTimers;\n  debounced.flush = flush;\n  return debounced;\n}\n","import { consoleSandbox } from '@sentry/utils';\n\nimport type { DeprecatedPrivacyOptions, ReplayIntegrationPrivacyOptions } from '../types';\n\ntype GetPrivacyOptions = Required<Omit<ReplayIntegrationPrivacyOptions, 'maskFn'>> &\n  Omit<DeprecatedPrivacyOptions, 'maskInputOptions'>;\ninterface GetPrivacyReturn {\n  maskTextSelector: string;\n  unmaskTextSelector: string;\n  blockSelector: string;\n  unblockSelector: string;\n  ignoreSelector: string;\n\n  blockClass?: RegExp;\n  maskTextClass?: RegExp;\n}\n\nfunction getOption(\n  selectors: string[],\n  defaultSelectors: string[],\n  deprecatedClassOption?: string | RegExp,\n  deprecatedSelectorOption?: string,\n): string {\n  const deprecatedSelectors = typeof deprecatedSelectorOption === 'string' ? deprecatedSelectorOption.split(',') : [];\n\n  const allSelectors = [\n    ...selectors,\n    // @deprecated\n    ...deprecatedSelectors,\n\n    // sentry defaults\n    ...defaultSelectors,\n  ];\n\n  // @deprecated\n  if (typeof deprecatedClassOption !== 'undefined') {\n    // NOTE: No support for RegExp\n    if (typeof deprecatedClassOption === 'string') {\n      allSelectors.push(`.${deprecatedClassOption}`);\n    }\n\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.warn(\n        '[Replay] You are using a deprecated configuration item for privacy. Read the documentation on how to use the new privacy configuration.',\n      );\n    });\n  }\n\n  return allSelectors.join(',');\n}\n\n/**\n * Returns privacy related configuration for use in rrweb\n */\nexport function getPrivacyOptions({\n  mask,\n  unmask,\n  block,\n  unblock,\n  ignore,\n\n  // eslint-disable-next-line deprecation/deprecation\n  blockClass,\n  // eslint-disable-next-line deprecation/deprecation\n  blockSelector,\n  // eslint-disable-next-line deprecation/deprecation\n  maskTextClass,\n  // eslint-disable-next-line deprecation/deprecation\n  maskTextSelector,\n  // eslint-disable-next-line deprecation/deprecation\n  ignoreClass,\n}: GetPrivacyOptions): GetPrivacyReturn {\n  const defaultBlockedElements = ['base[href=\"/\"]'];\n\n  const maskSelector = getOption(mask, ['.sentry-mask', '[data-sentry-mask]'], maskTextClass, maskTextSelector);\n  const unmaskSelector = getOption(unmask, ['.sentry-unmask', '[data-sentry-unmask]']);\n\n  const options: GetPrivacyReturn = {\n    // We are making the decision to make text and input selectors the same\n    maskTextSelector: maskSelector,\n    unmaskTextSelector: unmaskSelector,\n\n    blockSelector: getOption(\n      block,\n      ['.sentry-block', '[data-sentry-block]', ...defaultBlockedElements],\n      blockClass,\n      blockSelector,\n    ),\n    unblockSelector: getOption(unblock, ['.sentry-unblock', '[data-sentry-unblock]']),\n    ignoreSelector: getOption(ignore, ['.sentry-ignore', '[data-sentry-ignore]', 'input[type=\"file\"]'], ignoreClass),\n  };\n\n  if (blockClass instanceof RegExp) {\n    options.blockClass = blockClass;\n  }\n\n  if (maskTextClass instanceof RegExp) {\n    options.maskTextClass = maskTextClass;\n  }\n\n  return options;\n}\n","import { getClient } from '@sentry/core';\nimport type { BrowserClientReplayOptions, Integration, IntegrationFn } from '@sentry/types';\nimport { consoleSandbox, dropUndefinedKeys, isBrowser } from '@sentry/utils';\n\nimport {\n  DEFAULT_FLUSH_MAX_DELAY,\n  DEFAULT_FLUSH_MIN_DELAY,\n  MAX_REPLAY_DURATION,\n  MIN_REPLAY_DURATION,\n  MIN_REPLAY_DURATION_LIMIT,\n} from './constants';\nimport { ReplayContainer } from './replay';\nimport type {\n  RecordingOptions,\n  ReplayCanvasIntegrationOptions,\n  ReplayConfiguration,\n  ReplayPluginOptions,\n  SendBufferedReplayOptions,\n} from './types';\nimport { getPrivacyOptions } from './util/getPrivacyOptions';\nimport { maskAttribute } from './util/maskAttribute';\n\nconst MEDIA_SELECTORS =\n  'img,image,svg,video,object,picture,embed,map,audio,link[rel=\"icon\"],link[rel=\"apple-touch-icon\"]';\n\nconst DEFAULT_NETWORK_HEADERS = ['content-length', 'content-type', 'accept'];\n\nlet _initialized = false;\n\ntype InitialReplayPluginOptions = Omit<ReplayPluginOptions, 'sessionSampleRate' | 'errorSampleRate'> &\n  Partial<Pick<ReplayPluginOptions, 'sessionSampleRate' | 'errorSampleRate'>>;\n\nexport const replayIntegration = ((options?: ReplayConfiguration) => {\n  // eslint-disable-next-line deprecation/deprecation\n  return new Replay(options);\n}) satisfies IntegrationFn;\n\n/**\n * The main replay integration class, to be passed to `init({  integrations: [] })`.\n * @deprecated Use `replayIntegration()` instead.\n */\nexport class Replay implements Integration {\n  /**\n   * @inheritDoc\n   */\n  public static id: string = 'Replay';\n\n  /**\n   * @inheritDoc\n   */\n  public name: string;\n\n  /**\n   * Options to pass to `rrweb.record()`\n   */\n  private readonly _recordingOptions: RecordingOptions;\n\n  /**\n   * Initial options passed to the replay integration, merged with default values.\n   * Note: `sessionSampleRate` and `errorSampleRate` are not required here, as they\n   * can only be finally set when setupOnce() is called.\n   *\n   * @private\n   */\n  private readonly _initialOptions: InitialReplayPluginOptions;\n\n  private _replay?: ReplayContainer;\n\n  public constructor({\n    flushMinDelay = DEFAULT_FLUSH_MIN_DELAY,\n    flushMaxDelay = DEFAULT_FLUSH_MAX_DELAY,\n    minReplayDuration = MIN_REPLAY_DURATION,\n    maxReplayDuration = MAX_REPLAY_DURATION,\n    stickySession = true,\n    useCompression = true,\n    workerUrl,\n    _experiments = {},\n    sessionSampleRate,\n    errorSampleRate,\n    maskAllText = true,\n    maskAllInputs = true,\n    blockAllMedia = true,\n\n    mutationBreadcrumbLimit = 750,\n    mutationLimit = 10_000,\n\n    slowClickTimeout = 7_000,\n    slowClickIgnoreSelectors = [],\n\n    networkDetailAllowUrls = [],\n    networkDetailDenyUrls = [],\n    networkCaptureBodies = true,\n    networkRequestHeaders = [],\n    networkResponseHeaders = [],\n\n    mask = [],\n    maskAttributes = ['title', 'placeholder'],\n    unmask = [],\n    block = [],\n    unblock = [],\n    ignore = [],\n    maskFn,\n\n    beforeAddRecordingEvent,\n    beforeErrorSampling,\n\n    // eslint-disable-next-line deprecation/deprecation\n    blockClass,\n    // eslint-disable-next-line deprecation/deprecation\n    blockSelector,\n    // eslint-disable-next-line deprecation/deprecation\n    maskInputOptions,\n    // eslint-disable-next-line deprecation/deprecation\n    maskTextClass,\n    // eslint-disable-next-line deprecation/deprecation\n    maskTextSelector,\n    // eslint-disable-next-line deprecation/deprecation\n    ignoreClass,\n  }: ReplayConfiguration = {}) {\n    // eslint-disable-next-line deprecation/deprecation\n    this.name = Replay.id;\n\n    const privacyOptions = getPrivacyOptions({\n      mask,\n      unmask,\n      block,\n      unblock,\n      ignore,\n      blockClass,\n      blockSelector,\n      maskTextClass,\n      maskTextSelector,\n      ignoreClass,\n    });\n\n    this._recordingOptions = {\n      maskAllInputs,\n      maskAllText,\n      maskInputOptions: { ...(maskInputOptions || {}), password: true },\n      maskTextFn: maskFn,\n      maskInputFn: maskFn,\n      maskAttributeFn: (key: string, value: string, el: HTMLElement): string =>\n        maskAttribute({\n          maskAttributes,\n          maskAllText,\n          privacyOptions,\n          key,\n          value,\n          el,\n        }),\n\n      ...privacyOptions,\n\n      // Our defaults\n      slimDOMOptions: 'all',\n      inlineStylesheet: true,\n      // Disable inline images as it will increase segment/replay size\n      inlineImages: false,\n      // collect fonts, but be aware that `sentry.io` needs to be an allowed\n      // origin for playback\n      collectFonts: true,\n      errorHandler: (err: Error & { __rrweb__?: boolean }) => {\n        try {\n          err.__rrweb__ = true;\n        } catch (error) {\n          // ignore errors here\n          // this can happen if the error is frozen or does not allow mutation for other reasons\n        }\n      },\n    };\n\n    this._initialOptions = {\n      flushMinDelay,\n      flushMaxDelay,\n      minReplayDuration: Math.min(minReplayDuration, MIN_REPLAY_DURATION_LIMIT),\n      maxReplayDuration: Math.min(maxReplayDuration, MAX_REPLAY_DURATION),\n      stickySession,\n      sessionSampleRate,\n      errorSampleRate,\n      useCompression,\n      workerUrl,\n      blockAllMedia,\n      maskAllInputs,\n      maskAllText,\n      mutationBreadcrumbLimit,\n      mutationLimit,\n      slowClickTimeout,\n      slowClickIgnoreSelectors,\n      networkDetailAllowUrls,\n      networkDetailDenyUrls,\n      networkCaptureBodies,\n      networkRequestHeaders: _getMergedNetworkHeaders(networkRequestHeaders),\n      networkResponseHeaders: _getMergedNetworkHeaders(networkResponseHeaders),\n      beforeAddRecordingEvent,\n      beforeErrorSampling,\n\n      _experiments,\n    };\n\n    if (typeof sessionSampleRate === 'number') {\n      // eslint-disable-next-line\n      console.warn(\n        `[Replay] You are passing \\`sessionSampleRate\\` to the Replay integration.\nThis option is deprecated and will be removed soon.\nInstead, configure \\`replaysSessionSampleRate\\` directly in the SDK init options, e.g.:\nSentry.init({ replaysSessionSampleRate: ${sessionSampleRate} })`,\n      );\n\n      this._initialOptions.sessionSampleRate = sessionSampleRate;\n    }\n\n    if (typeof errorSampleRate === 'number') {\n      // eslint-disable-next-line\n      console.warn(\n        `[Replay] You are passing \\`errorSampleRate\\` to the Replay integration.\nThis option is deprecated and will be removed soon.\nInstead, configure \\`replaysOnErrorSampleRate\\` directly in the SDK init options, e.g.:\nSentry.init({ replaysOnErrorSampleRate: ${errorSampleRate} })`,\n      );\n\n      this._initialOptions.errorSampleRate = errorSampleRate;\n    }\n\n    if (this._initialOptions.blockAllMedia) {\n      // `blockAllMedia` is a more user friendly option to configure blocking\n      // embedded media elements\n      this._recordingOptions.blockSelector = !this._recordingOptions.blockSelector\n        ? MEDIA_SELECTORS\n        : `${this._recordingOptions.blockSelector},${MEDIA_SELECTORS}`;\n    }\n\n    if (this._isInitialized && isBrowser()) {\n      throw new Error('Multiple Sentry Session Replay instances are not supported');\n    }\n\n    this._isInitialized = true;\n  }\n\n  /** If replay has already been initialized */\n  protected get _isInitialized(): boolean {\n    return _initialized;\n  }\n\n  /** Update _isInitialized */\n  protected set _isInitialized(value: boolean) {\n    _initialized = value;\n  }\n\n  /**\n   * Setup and initialize replay container\n   */\n  public setupOnce(): void {\n    if (!isBrowser()) {\n      return;\n    }\n\n    this._setup();\n\n    // Once upon a time, we tried to create a transaction in `setupOnce` and it would\n    // potentially create a transaction before some native SDK integrations have run\n    // and applied their own global event processor. An example is:\n    // https://github.com/getsentry/sentry-javascript/blob/b47ceafbdac7f8b99093ce6023726ad4687edc48/packages/browser/src/integrations/useragent.ts\n    //\n    // So we call `this._initialize()` in next event loop as a workaround to wait for other\n    // global event processors to finish. This is no longer needed, but keeping it\n    // here to avoid any future issues.\n    setTimeout(() => this._initialize());\n  }\n\n  /**\n   * Start a replay regardless of sampling rate. Calling this will always\n   * create a new session. Will throw an error if replay is already in progress.\n   *\n   * Creates or loads a session, attaches listeners to varying events (DOM,\n   * PerformanceObserver, Recording, Sentry SDK, etc)\n   */\n  public start(): void {\n    if (!this._replay) {\n      return;\n    }\n\n    this._replay.start();\n  }\n\n  /**\n   * Start replay buffering. Buffers until `flush()` is called or, if\n   * `replaysOnErrorSampleRate` > 0, until an error occurs.\n   */\n  public startBuffering(): void {\n    if (!this._replay) {\n      return;\n    }\n\n    this._replay.startBuffering();\n  }\n\n  /**\n   * Currently, this needs to be manually called (e.g. for tests). Sentry SDK\n   * does not support a teardown\n   */\n  public stop(): Promise<void> {\n    if (!this._replay) {\n      return Promise.resolve();\n    }\n\n    return this._replay.stop({ forceFlush: this._replay.recordingMode === 'session' });\n  }\n\n  /**\n   * If not in \"session\" recording mode, flush event buffer which will create a new replay.\n   * Unless `continueRecording` is false, the replay will continue to record and\n   * behave as a \"session\"-based replay.\n   *\n   * Otherwise, queue up a flush.\n   */\n  public flush(options?: SendBufferedReplayOptions): Promise<void> {\n    if (!this._replay || !this._replay.isEnabled()) {\n      return Promise.resolve();\n    }\n\n    return this._replay.sendBufferedReplayOrFlush(options);\n  }\n\n  /**\n   * Get the current session ID.\n   */\n  public getReplayId(): string | undefined {\n    if (!this._replay || !this._replay.isEnabled()) {\n      return;\n    }\n\n    return this._replay.getSessionId();\n  }\n\n  /**\n   * Initializes replay.\n   */\n  protected _initialize(): void {\n    if (!this._replay) {\n      return;\n    }\n\n    // We have to run this in _initialize, because this runs in setTimeout\n    // So when this runs all integrations have been added\n    // Before this, we cannot access integrations on the client,\n    // so we need to mutate the options here\n    this._maybeLoadFromReplayCanvasIntegration();\n\n    this._replay.initializeSampling();\n  }\n\n  /** Setup the integration. */\n  private _setup(): void {\n    // Client is not available in constructor, so we need to wait until setupOnce\n    const finalOptions = loadReplayOptionsFromClient(this._initialOptions);\n\n    this._replay = new ReplayContainer({\n      options: finalOptions,\n      recordingOptions: this._recordingOptions,\n    });\n  }\n\n  /** Get canvas options from ReplayCanvas integration, if it is also added. */\n  private _maybeLoadFromReplayCanvasIntegration(): void {\n    // To save bundle size, we skip checking for stuff here\n    // and instead just try-catch everything - as generally this should all be defined\n    /* eslint-disable @typescript-eslint/no-non-null-assertion */\n    try {\n      const client = getClient()!;\n      const canvasIntegration = client.getIntegrationByName!('ReplayCanvas') as Integration & {\n        getOptions(): ReplayCanvasIntegrationOptions;\n      };\n      if (!canvasIntegration) {\n        return;\n      }\n\n      this._replay!['_canvas'] = canvasIntegration.getOptions();\n    } catch {\n      // ignore errors here\n    }\n    /* eslint-enable @typescript-eslint/no-non-null-assertion */\n  }\n}\n\n/** Parse Replay-related options from SDK options */\nfunction loadReplayOptionsFromClient(initialOptions: InitialReplayPluginOptions): ReplayPluginOptions {\n  const client = getClient();\n  const opt = client && (client.getOptions() as BrowserClientReplayOptions);\n\n  const finalOptions = { sessionSampleRate: 0, errorSampleRate: 0, ...dropUndefinedKeys(initialOptions) };\n\n  if (!opt) {\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.warn('SDK client is not available.');\n    });\n    return finalOptions;\n  }\n\n  if (\n    initialOptions.sessionSampleRate == null && // TODO remove once deprecated rates are removed\n    initialOptions.errorSampleRate == null && // TODO remove once deprecated rates are removed\n    opt.replaysSessionSampleRate == null &&\n    opt.replaysOnErrorSampleRate == null\n  ) {\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.warn(\n        'Replay is disabled because neither `replaysSessionSampleRate` nor `replaysOnErrorSampleRate` are set.',\n      );\n    });\n  }\n\n  if (typeof opt.replaysSessionSampleRate === 'number') {\n    finalOptions.sessionSampleRate = opt.replaysSessionSampleRate;\n  }\n\n  if (typeof opt.replaysOnErrorSampleRate === 'number') {\n    finalOptions.errorSampleRate = opt.replaysOnErrorSampleRate;\n  }\n\n  return finalOptions;\n}\n\nfunction _getMergedNetworkHeaders(headers: string[]): string[] {\n  return [...DEFAULT_NETWORK_HEADERS, ...headers.map(header => header.toLowerCase())];\n}\n","import type { getPrivacyOptions } from './getPrivacyOptions';\n\ninterface MaskAttributeParams {\n  maskAttributes: string[];\n  maskAllText: boolean;\n  privacyOptions: ReturnType<typeof getPrivacyOptions>;\n  key: string;\n  value: string;\n  el: HTMLElement;\n}\n\n/**\n * Masks an attribute if necessary, otherwise return attribute value as-is.\n */\nexport function maskAttribute({\n  el,\n  key,\n  maskAttributes,\n  maskAllText,\n  privacyOptions,\n  value,\n}: MaskAttributeParams): string {\n  // We only mask attributes if `maskAllText` is true\n  if (!maskAllText) {\n    return value;\n  }\n\n  // unmaskTextSelector takes precendence\n  if (privacyOptions.unmaskTextSelector && el.matches(privacyOptions.unmaskTextSelector)) {\n    return value;\n  }\n\n  if (\n    maskAttributes.includes(key) ||\n    // Need to mask `value` attribute for `<input>` if it's a button-like\n    // type\n    (key === 'value' && el.tagName === 'INPUT' && ['submit', 'button'].includes(el.getAttribute('type') || ''))\n  ) {\n    return value.replace(/[\\S]/g, '*');\n  }\n\n  return value;\n}\n","import { getClient } from '@sentry/core';\nimport type { replayIntegration } from '../integration';\n\n/**\n * This is a small utility to get a type-safe instance of the Replay integration.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport function getReplay(): ReturnType<typeof replayIntegration> | undefined {\n  const client = getClient();\n  return (\n    client && client.getIntegrationByName && client.getIntegrationByName<ReturnType<typeof replayIntegration>>('Replay')\n  );\n}\n","import type { Client, DsnComponents, Hub } from '@sentry/types';\n\n/**\n * Checks whether given url points to Sentry server\n * @param url url to verify\n *\n * TODO(v8): Remove Hub fallback type\n */\n// eslint-disable-next-line deprecation/deprecation\nexport function isSentryRequestUrl(url: string, hubOrClient: Hub | Client | undefined): boolean {\n  const client =\n    hubOrClient && isHub(hubOrClient)\n      ? // eslint-disable-next-line deprecation/deprecation\n        hubOrClient.getClient()\n      : hubOrClient;\n  const dsn = client && client.getDsn();\n  const tunnel = client && client.getOptions().tunnel;\n\n  return checkDsn(url, dsn) || checkTunnel(url, tunnel);\n}\n\nfunction checkTunnel(url: string, tunnel: string | undefined): boolean {\n  if (!tunnel) {\n    return false;\n  }\n\n  return removeTrailingSlash(url) === removeTrailingSlash(tunnel);\n}\n\nfunction checkDsn(url: string, dsn: DsnComponents | undefined): boolean {\n  return dsn ? url.includes(dsn.host) : false;\n}\n\nfunction removeTrailingSlash(str: string): string {\n  return str[str.length - 1] === '/' ? str.slice(0, -1) : str;\n}\n\n// eslint-disable-next-line deprecation/deprecation\nfunction isHub(hubOrClient: Hub | Client | undefined): hubOrClient is Hub {\n  // eslint-disable-next-line deprecation/deprecation\n  return (hubOrClient as Hub).getClient !== undefined;\n}\n","import type {\n  Context,\n  Contexts,\n  DynamicSamplingContext,\n  MeasurementUnit,\n  SpanTimeInput,\n  Transaction as TransactionInterface,\n  TransactionContext,\n  TransactionEvent,\n  TransactionMetadata,\n} from '@sentry/types';\nimport { dropUndefinedKeys, logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport type { Hub } from '../hub';\nimport { getCurrentHub } from '../hub';\nimport { getMetricSummaryJsonForSpan } from '../metrics/metric-summary';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '../semanticAttributes';\nimport { spanTimeInputToSeconds, spanToJSON, spanToTraceContext } from '../utils/spanUtils';\nimport { getDynamicSamplingContextFromSpan } from './dynamicSamplingContext';\nimport { Span as SpanClass, SpanRecorder } from './span';\nimport { getCapturedScopesOnSpan } from './trace';\n\n/** JSDoc */\nexport class Transaction extends SpanClass implements TransactionInterface {\n  /**\n   * The reference to the current hub.\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  public _hub: Hub;\n\n  protected _name: string;\n\n  private _contexts: Contexts;\n\n  private _trimEnd?: boolean | undefined;\n\n  // DO NOT yet remove this property, it is used in a hack for v7 backwards compatibility.\n  private _frozenDynamicSamplingContext: Readonly<Partial<DynamicSamplingContext>> | undefined;\n\n  private _metadata: Partial<TransactionMetadata>;\n\n  /**\n   * This constructor should never be called manually. Those instrumenting tracing should use\n   * `Sentry.startTransaction()`, and internal methods should use `hub.startTransaction()`.\n   * @internal\n   * @hideconstructor\n   * @hidden\n   *\n   * @deprecated Transactions will be removed in v8. Use spans instead.\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  public constructor(transactionContext: TransactionContext, hub?: Hub) {\n    super(transactionContext);\n    this._contexts = {};\n\n    // eslint-disable-next-line deprecation/deprecation\n    this._hub = hub || getCurrentHub();\n\n    this._name = transactionContext.name || '';\n\n    this._metadata = {\n      // eslint-disable-next-line deprecation/deprecation\n      ...transactionContext.metadata,\n    };\n\n    this._trimEnd = transactionContext.trimEnd;\n\n    // this is because transactions are also spans, and spans have a transaction pointer\n    // TODO (v8): Replace this with another way to set the root span\n    // eslint-disable-next-line deprecation/deprecation\n    this.transaction = this;\n\n    // If Dynamic Sampling Context is provided during the creation of the transaction, we freeze it as it usually means\n    // there is incoming Dynamic Sampling Context. (Either through an incoming request, a baggage meta-tag, or other means)\n    const incomingDynamicSamplingContext = this._metadata.dynamicSamplingContext;\n    if (incomingDynamicSamplingContext) {\n      // We shallow copy this in case anything writes to the original reference of the passed in `dynamicSamplingContext`\n      this._frozenDynamicSamplingContext = { ...incomingDynamicSamplingContext };\n    }\n  }\n\n  // This sadly conflicts with the getter/setter ordering :(\n  /* eslint-disable @typescript-eslint/member-ordering */\n\n  /**\n   * Getter for `name` property.\n   * @deprecated Use `spanToJSON(span).description` instead.\n   */\n  public get name(): string {\n    return this._name;\n  }\n\n  /**\n   * Setter for `name` property, which also sets `source` as custom.\n   * @deprecated Use `updateName()` and `setMetadata()` instead.\n   */\n  public set name(newName: string) {\n    // eslint-disable-next-line deprecation/deprecation\n    this.setName(newName);\n  }\n\n  /**\n   * Get the metadata for this transaction.\n   * @deprecated Use `spanGetMetadata(transaction)` instead.\n   */\n  public get metadata(): TransactionMetadata {\n    // We merge attributes in for backwards compatibility\n    return {\n      // Defaults\n      // eslint-disable-next-line deprecation/deprecation\n      source: 'custom',\n      spanMetadata: {},\n\n      // Legacy metadata\n      ...this._metadata,\n\n      // From attributes\n      ...(this._attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] && {\n        source: this._attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE] as TransactionMetadata['source'],\n      }),\n      ...(this._attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE] && {\n        sampleRate: this._attributes[SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE] as TransactionMetadata['sampleRate'],\n      }),\n    };\n  }\n\n  /**\n   * Update the metadata for this transaction.\n   * @deprecated Use `spanGetMetadata(transaction)` instead.\n   */\n  public set metadata(metadata: TransactionMetadata) {\n    this._metadata = metadata;\n  }\n\n  /* eslint-enable @typescript-eslint/member-ordering */\n\n  /**\n   * Setter for `name` property, which also sets `source` on the metadata.\n   *\n   * @deprecated Use `.updateName()` and `.setAttribute()` instead.\n   */\n  public setName(name: string, source: TransactionMetadata['source'] = 'custom'): void {\n    this._name = name;\n    this.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, source);\n  }\n\n  /** @inheritdoc */\n  public updateName(name: string): this {\n    this._name = name;\n    return this;\n  }\n\n  /**\n   * Attaches SpanRecorder to the span itself\n   * @param maxlen maximum number of spans that can be recorded\n   */\n  public initSpanRecorder(maxlen: number = 1000): void {\n    // eslint-disable-next-line deprecation/deprecation\n    if (!this.spanRecorder) {\n      // eslint-disable-next-line deprecation/deprecation\n      this.spanRecorder = new SpanRecorder(maxlen);\n    }\n    // eslint-disable-next-line deprecation/deprecation\n    this.spanRecorder.add(this);\n  }\n\n  /**\n   * Set the context of a transaction event.\n   * @deprecated Use either `.setAttribute()`, or set the context on the scope before creating the transaction.\n   */\n  public setContext(key: string, context: Context | null): void {\n    if (context === null) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete this._contexts[key];\n    } else {\n      this._contexts[key] = context;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Use top-level `setMeasurement()` instead.\n   */\n  public setMeasurement(name: string, value: number, unit: MeasurementUnit = ''): void {\n    this._measurements[name] = { value, unit };\n  }\n\n  /**\n   * Store metadata on this transaction.\n   * @deprecated Use attributes or store data on the scope instead.\n   */\n  public setMetadata(newMetadata: Partial<TransactionMetadata>): void {\n    this._metadata = { ...this._metadata, ...newMetadata };\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public end(endTimestamp?: SpanTimeInput): string | undefined {\n    const timestampInS = spanTimeInputToSeconds(endTimestamp);\n    const transaction = this._finishTransaction(timestampInS);\n    if (!transaction) {\n      return undefined;\n    }\n    // eslint-disable-next-line deprecation/deprecation\n    return this._hub.captureEvent(transaction);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public toContext(): TransactionContext {\n    // eslint-disable-next-line deprecation/deprecation\n    const spanContext = super.toContext();\n\n    return dropUndefinedKeys({\n      ...spanContext,\n      name: this._name,\n      trimEnd: this._trimEnd,\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public updateWithContext(transactionContext: TransactionContext): this {\n    // eslint-disable-next-line deprecation/deprecation\n    super.updateWithContext(transactionContext);\n\n    this._name = transactionContext.name || '';\n    this._trimEnd = transactionContext.trimEnd;\n\n    return this;\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * @experimental\n   *\n   * @deprecated Use top-level `getDynamicSamplingContextFromSpan` instead.\n   */\n  public getDynamicSamplingContext(): Readonly<Partial<DynamicSamplingContext>> {\n    return getDynamicSamplingContextFromSpan(this);\n  }\n\n  /**\n   * Override the current hub with a new one.\n   * Used if you want another hub to finish the transaction.\n   *\n   * @internal\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  public setHub(hub: Hub): void {\n    this._hub = hub;\n  }\n\n  /**\n   * Get the profile id of the transaction.\n   */\n  public getProfileId(): string | undefined {\n    if (this._contexts !== undefined && this._contexts['profile'] !== undefined) {\n      return this._contexts['profile'].profile_id as string;\n    }\n    return undefined;\n  }\n\n  /**\n   * Finish the transaction & prepare the event to send to Sentry.\n   */\n  protected _finishTransaction(endTimestamp?: number): TransactionEvent | undefined {\n    // This transaction is already finished, so we should not flush it again.\n    if (this._endTime !== undefined) {\n      return undefined;\n    }\n\n    if (!this._name) {\n      DEBUG_BUILD && logger.warn('Transaction has no name, falling back to `<unlabeled transaction>`.');\n      this._name = '<unlabeled transaction>';\n    }\n\n    // just sets the end timestamp\n    super.end(endTimestamp);\n\n    // eslint-disable-next-line deprecation/deprecation\n    const client = this._hub.getClient();\n    if (client && client.emit) {\n      client.emit('finishTransaction', this);\n    }\n\n    if (this._sampled !== true) {\n      // At this point if `sampled !== true` we want to discard the transaction.\n      DEBUG_BUILD && logger.log('[Tracing] Discarding transaction because its trace was not chosen to be sampled.');\n\n      if (client) {\n        client.recordDroppedEvent('sample_rate', 'transaction');\n      }\n\n      return undefined;\n    }\n\n    // eslint-disable-next-line deprecation/deprecation\n    const finishedSpans = this.spanRecorder\n      ? // eslint-disable-next-line deprecation/deprecation\n        this.spanRecorder.spans.filter(span => span !== this && spanToJSON(span).timestamp)\n      : [];\n\n    if (this._trimEnd && finishedSpans.length > 0) {\n      const endTimes = finishedSpans.map(span => spanToJSON(span).timestamp).filter(Boolean) as number[];\n      this._endTime = endTimes.reduce((prev, current) => {\n        return prev > current ? prev : current;\n      });\n    }\n\n    const { scope: capturedSpanScope, isolationScope: capturedSpanIsolationScope } = getCapturedScopesOnSpan(this);\n\n    // eslint-disable-next-line deprecation/deprecation\n    const { metadata } = this;\n    // eslint-disable-next-line deprecation/deprecation\n    const { source } = metadata;\n\n    const transaction: TransactionEvent = {\n      contexts: {\n        ...this._contexts,\n        // We don't want to override trace context\n        trace: spanToTraceContext(this),\n      },\n      // TODO: Pass spans serialized via `spanToJSON()` here instead in v8.\n      spans: finishedSpans,\n      start_timestamp: this._startTime,\n      // eslint-disable-next-line deprecation/deprecation\n      tags: this.tags,\n      timestamp: this._endTime,\n      transaction: this._name,\n      type: 'transaction',\n      sdkProcessingMetadata: {\n        ...metadata,\n        capturedSpanScope,\n        capturedSpanIsolationScope,\n        ...dropUndefinedKeys({\n          dynamicSamplingContext: getDynamicSamplingContextFromSpan(this),\n        }),\n      },\n      _metrics_summary: getMetricSummaryJsonForSpan(this),\n      ...(source && {\n        transaction_info: {\n          source,\n        },\n      }),\n    };\n\n    const hasMeasurements = Object.keys(this._measurements).length > 0;\n\n    if (hasMeasurements) {\n      DEBUG_BUILD &&\n        logger.log(\n          '[Measurements] Adding measurements to transaction',\n          JSON.stringify(this._measurements, undefined, 2),\n        );\n      transaction.measurements = this._measurements;\n    }\n\n    // eslint-disable-next-line deprecation/deprecation\n    DEBUG_BUILD && logger.log(`[Tracing] Finishing ${this.op} transaction: ${this._name}.`);\n\n    return transaction;\n  }\n}\n","import type { MeasurementUnit, MetricBucketItem, Primitive } from '@sentry/types';\nimport { dropUndefinedKeys } from '@sentry/utils';\nimport type { MetricType } from './types';\n\n/**\n * Generate bucket key from metric properties.\n */\nexport function getBucketKey(\n  metricType: MetricType,\n  name: string,\n  unit: MeasurementUnit,\n  tags: Record<string, string>,\n): string {\n  const stringifiedTags = Object.entries(dropUndefinedKeys(tags)).sort((a, b) => a[0].localeCompare(b[0]));\n  return `${metricType}${name}${unit}${stringifiedTags}`;\n}\n\n/* eslint-disable no-bitwise */\n/**\n * Simple hash function for strings.\n */\nexport function simpleHash(s: string): number {\n  let rv = 0;\n  for (let i = 0; i < s.length; i++) {\n    const c = s.charCodeAt(i);\n    rv = (rv << 5) - rv + c;\n    rv &= rv;\n  }\n  return rv >>> 0;\n}\n/* eslint-enable no-bitwise */\n\n/**\n * Serialize metrics buckets into a string based on statsd format.\n *\n * Example of format:\n * metric.name@second:1:1.2|d|#a:value,b:anothervalue|T12345677\n * Segments:\n * name: metric.name\n * unit: second\n * value: [1, 1.2]\n * type of metric: d (distribution)\n * tags: { a: value, b: anothervalue }\n * timestamp: 12345677\n */\nexport function serializeMetricBuckets(metricBucketItems: MetricBucketItem[]): string {\n  let out = '';\n  for (const item of metricBucketItems) {\n    const tagEntries = Object.entries(item.tags);\n    const maybeTags = tagEntries.length > 0 ? `|#${tagEntries.map(([key, value]) => `${key}:${value}`).join(',')}` : '';\n    out += `${item.name}@${item.unit}:${item.metric}|${item.metricType}${maybeTags}|T${item.timestamp}\\n`;\n  }\n  return out;\n}\n\n/** Sanitizes units */\nexport function sanitizeUnit(unit: string): string {\n  return unit.replace(/[^\\w]+/gi, '_');\n}\n\n/** Sanitizes metric keys */\nexport function sanitizeMetricKey(key: string): string {\n  return key.replace(/[^\\w\\-.]+/gi, '_');\n}\n\nfunction sanitizeTagKey(key: string): string {\n  return key.replace(/[^\\w\\-./]+/gi, '');\n}\n\nconst tagValueReplacements: [string, string][] = [\n  ['\\n', '\\\\n'],\n  ['\\r', '\\\\r'],\n  ['\\t', '\\\\t'],\n  ['\\\\', '\\\\\\\\'],\n  ['|', '\\\\u{7c}'],\n  [',', '\\\\u{2c}'],\n];\n\nfunction getCharOrReplacement(input: string): string {\n  for (const [search, replacement] of tagValueReplacements) {\n    if (input === search) {\n      return replacement;\n    }\n  }\n\n  return input;\n}\n\nfunction sanitizeTagValue(value: string): string {\n  return [...value].reduce((acc, char) => acc + getCharOrReplacement(char), '');\n}\n\n/**\n * Sanitizes tags.\n */\nexport function sanitizeTags(unsanitizedTags: Record<string, Primitive>): Record<string, string> {\n  const tags: Record<string, string> = {};\n  for (const key in unsanitizedTags) {\n    if (Object.prototype.hasOwnProperty.call(unsanitizedTags, key)) {\n      const sanitizedKey = sanitizeTagKey(key);\n      tags[sanitizedKey] = sanitizeTagValue(String(unsanitizedTags[key]));\n    }\n  }\n  return tags;\n}\n","import { isNativeFetch, logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport { WINDOW } from '../helpers';\n\nlet cachedFetchImpl: FetchImpl | undefined = undefined;\n\nexport type FetchImpl = typeof fetch;\n\n/**\n * A special usecase for incorrectly wrapped Fetch APIs in conjunction with ad-blockers.\n * Whenever someone wraps the Fetch API and returns the wrong promise chain,\n * this chain becomes orphaned and there is no possible way to capture it's rejections\n * other than allowing it bubble up to this very handler. eg.\n *\n * const f = window.fetch;\n * window.fetch = function () {\n *   const p = f.apply(this, arguments);\n *\n *   p.then(function() {\n *     console.log('hi.');\n *   });\n *\n *   return p;\n * }\n *\n * `p.then(function () { ... })` is producing a completely separate promise chain,\n * however, what's returned is `p` - the result of original `fetch` call.\n *\n * This mean, that whenever we use the Fetch API to send our own requests, _and_\n * some ad-blocker blocks it, this orphaned chain will _always_ reject,\n * effectively causing another event to be captured.\n * This makes a whole process become an infinite loop, which we need to somehow\n * deal with, and break it in one way or another.\n *\n * To deal with this issue, we are making sure that we _always_ use the real\n * browser Fetch API, instead of relying on what `window.fetch` exposes.\n * The only downside to this would be missing our own requests as breadcrumbs,\n * but because we are already not doing this, it should be just fine.\n *\n * Possible failed fetch error messages per-browser:\n *\n * Chrome:  Failed to fetch\n * Edge:    Failed to Fetch\n * Firefox: NetworkError when attempting to fetch resource\n * Safari:  resource blocked by content blocker\n */\nexport function getNativeFetchImplementation(): FetchImpl {\n  if (cachedFetchImpl) {\n    return cachedFetchImpl;\n  }\n\n  /* eslint-disable @typescript-eslint/unbound-method */\n\n  // Fast path to avoid DOM I/O\n  if (isNativeFetch(WINDOW.fetch)) {\n    return (cachedFetchImpl = WINDOW.fetch.bind(WINDOW));\n  }\n\n  const document = WINDOW.document;\n  let fetchImpl = WINDOW.fetch;\n  // eslint-disable-next-line deprecation/deprecation\n  if (document && typeof document.createElement === 'function') {\n    try {\n      const sandbox = document.createElement('iframe');\n      sandbox.hidden = true;\n      document.head.appendChild(sandbox);\n      const contentWindow = sandbox.contentWindow;\n      if (contentWindow && contentWindow.fetch) {\n        fetchImpl = contentWindow.fetch;\n      }\n      document.head.removeChild(sandbox);\n    } catch (e) {\n      DEBUG_BUILD && logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', e);\n    }\n  }\n\n  return (cachedFetchImpl = fetchImpl.bind(WINDOW));\n  /* eslint-enable @typescript-eslint/unbound-method */\n}\n\n/** Clears cached fetch impl */\nexport function clearCachedFetchImplementation(): void {\n  cachedFetchImpl = undefined;\n}\n","import { createTransport } from '@sentry/core';\nimport type { Transport, TransportMakeRequestResponse, TransportRequest } from '@sentry/types';\nimport { rejectedSyncPromise } from '@sentry/utils';\n\nimport type { BrowserTransportOptions } from './types';\nimport type { FetchImpl } from './utils';\nimport { clearCachedFetchImplementation, getNativeFetchImplementation } from './utils';\n\n/**\n * Creates a Transport that uses the Fetch API to send events to Sentry.\n */\nexport function makeFetchTransport(\n  options: BrowserTransportOptions,\n  nativeFetch: FetchImpl = getNativeFetchImplementation(),\n): Transport {\n  let pendingBodySize = 0;\n  let pendingCount = 0;\n\n  function makeRequest(request: TransportRequest): PromiseLike<TransportMakeRequestResponse> {\n    const requestSize = request.body.length;\n    pendingBodySize += requestSize;\n    pendingCount++;\n\n    const requestOptions: RequestInit = {\n      body: request.body,\n      method: 'POST',\n      referrerPolicy: 'origin',\n      headers: options.headers,\n      // Outgoing requests are usually cancelled when navigating to a different page, causing a \"TypeError: Failed to\n      // fetch\" error and sending a \"network_error\" client-outcome - in Chrome, the request status shows \"(cancelled)\".\n      // The `keepalive` flag keeps outgoing requests alive, even when switching pages. We want this since we're\n      // frequently sending events right before the user is switching pages (eg. whenfinishing navigation transactions).\n      // Gotchas:\n      // - `keepalive` isn't supported by Firefox\n      // - As per spec (https://fetch.spec.whatwg.org/#http-network-or-cache-fetch):\n      //   If the sum of contentLength and inflightKeepaliveBytes is greater than 64 kibibytes, then return a network error.\n      //   We will therefore only activate the flag when we're below that limit.\n      // There is also a limit of requests that can be open at the same time, so we also limit this to 15\n      // See https://github.com/getsentry/sentry-javascript/pull/7553 for details\n      keepalive: pendingBodySize <= 60_000 && pendingCount < 15,\n      ...options.fetchOptions,\n    };\n\n    try {\n      return nativeFetch(options.url, requestOptions).then(response => {\n        pendingBodySize -= requestSize;\n        pendingCount--;\n        return {\n          statusCode: response.status,\n          headers: {\n            'x-sentry-rate-limits': response.headers.get('X-Sentry-Rate-Limits'),\n            'retry-after': response.headers.get('Retry-After'),\n          },\n        };\n      });\n    } catch (e) {\n      clearCachedFetchImplementation();\n      pendingBodySize -= requestSize;\n      pendingCount--;\n      return rejectedSyncPromise(e);\n    }\n  }\n\n  return createTransport(options, makeRequest);\n}\n","import type { DsnComponents, EventEnvelope, SdkMetadata, UserFeedback, UserFeedbackItem } from '@sentry/types';\nimport { createEnvelope, dsnToString } from '@sentry/utils';\n\n/**\n * Creates an envelope from a user feedback.\n */\nexport function createUserFeedbackEnvelope(\n  feedback: UserFeedback,\n  {\n    metadata,\n    tunnel,\n    dsn,\n  }: {\n    metadata: SdkMetadata | undefined;\n    tunnel: string | undefined;\n    dsn: DsnComponents | undefined;\n  },\n): EventEnvelope {\n  const headers: EventEnvelope[0] = {\n    event_id: feedback.event_id,\n    sent_at: new Date().toISOString(),\n    ...(metadata &&\n      metadata.sdk && {\n        sdk: {\n          name: metadata.sdk.name,\n          version: metadata.sdk.version,\n        },\n      }),\n    ...(!!tunnel && !!dsn && { dsn: dsnToString(dsn) }),\n  };\n  const item = createUserFeedbackEnvelopeItem(feedback);\n\n  return createEnvelope(headers, [item]);\n}\n\nfunction createUserFeedbackEnvelopeItem(feedback: UserFeedback): UserFeedbackItem {\n  const feedbackHeaders: UserFeedbackItem[0] = {\n    type: 'user_report',\n  };\n  return [feedbackHeaders, feedback];\n}\n","/* eslint-disable max-lines */\nimport type {\n  Instrumenter,\n  Measurements,\n  Primitive,\n  Span as SpanInterface,\n  SpanAttributeValue,\n  SpanAttributes,\n  SpanContext,\n  SpanContextData,\n  SpanJSON,\n  SpanOrigin,\n  SpanTimeInput,\n  TraceContext,\n  Transaction,\n} from '@sentry/types';\nimport { dropUndefinedKeys, logger, timestampInSeconds, uuid4 } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport { getMetricSummaryJsonForSpan } from '../metrics/metric-summary';\nimport {\n  SEMANTIC_ATTRIBUTE_PROFILE_ID,\n  SEMANTIC_ATTRIBUTE_SENTRY_OP,\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n} from '../semanticAttributes';\nimport { getRootSpan } from '../utils/getRootSpan';\nimport {\n  TRACE_FLAG_NONE,\n  TRACE_FLAG_SAMPLED,\n  spanTimeInputToSeconds,\n  spanToJSON,\n  spanToTraceContext,\n  spanToTraceHeader,\n} from '../utils/spanUtils';\nimport type { SpanStatusType } from './spanstatus';\nimport { setHttpStatus } from './spanstatus';\n\n/**\n * Keeps track of finished spans for a given transaction\n * @internal\n * @hideconstructor\n * @hidden\n */\nexport class SpanRecorder {\n  public spans: Span[];\n\n  private readonly _maxlen: number;\n\n  public constructor(maxlen: number = 1000) {\n    this._maxlen = maxlen;\n    this.spans = [];\n  }\n\n  /**\n   * This is just so that we don't run out of memory while recording a lot\n   * of spans. At some point we just stop and flush out the start of the\n   * trace tree (i.e.the first n spans with the smallest\n   * start_timestamp).\n   */\n  public add(span: Span): void {\n    if (this.spans.length > this._maxlen) {\n      // eslint-disable-next-line deprecation/deprecation\n      span.spanRecorder = undefined;\n    } else {\n      this.spans.push(span);\n    }\n  }\n}\n\n/**\n * Span contains all data about a span\n */\nexport class Span implements SpanInterface {\n  /**\n   * Tags for the span.\n   * @deprecated Use `spanToJSON(span).atttributes` instead.\n   */\n  public tags: { [key: string]: Primitive };\n\n  /**\n   * Data for the span.\n   * @deprecated Use `spanToJSON(span).atttributes` instead.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public data: { [key: string]: any };\n\n  /**\n   * List of spans that were finalized\n   *\n   * @deprecated This property will no longer be public. Span recording will be handled internally.\n   */\n  public spanRecorder?: SpanRecorder;\n\n  /**\n   * @inheritDoc\n   * @deprecated Use top level `Sentry.getRootSpan()` instead\n   */\n  public transaction?: Transaction;\n\n  /**\n   * The instrumenter that created this span.\n   *\n   * TODO (v8): This can probably be replaced by an `instanceOf` check of the span class.\n   *            the instrumenter can only be sentry or otel so we can check the span instance\n   *            to verify which one it is and remove this field entirely.\n   *\n   * @deprecated This field will be removed.\n   */\n  public instrumenter: Instrumenter;\n\n  protected _traceId: string;\n  protected _spanId: string;\n  protected _parentSpanId?: string | undefined;\n  protected _sampled: boolean | undefined;\n  protected _name?: string | undefined;\n  protected _attributes: SpanAttributes;\n  /** Epoch timestamp in seconds when the span started. */\n  protected _startTime: number;\n  /** Epoch timestamp in seconds when the span ended. */\n  protected _endTime?: number | undefined;\n  /** Internal keeper of the status */\n  protected _status?: SpanStatusType | string | undefined;\n  protected _exclusiveTime?: number;\n\n  protected _measurements: Measurements;\n\n  private _logMessage?: string;\n\n  /**\n   * You should never call the constructor manually, always use `Sentry.startTransaction()`\n   * or call `startChild()` on an existing span.\n   * @internal\n   * @hideconstructor\n   * @hidden\n   */\n  public constructor(spanContext: SpanContext = {}) {\n    this._traceId = spanContext.traceId || uuid4();\n    this._spanId = spanContext.spanId || uuid4().substring(16);\n    this._startTime = spanContext.startTimestamp || timestampInSeconds();\n    // eslint-disable-next-line deprecation/deprecation\n    this.tags = spanContext.tags ? { ...spanContext.tags } : {};\n    // eslint-disable-next-line deprecation/deprecation\n    this.data = spanContext.data ? { ...spanContext.data } : {};\n    // eslint-disable-next-line deprecation/deprecation\n    this.instrumenter = spanContext.instrumenter || 'sentry';\n\n    this._attributes = {};\n    this.setAttributes({\n      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: spanContext.origin || 'manual',\n      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: spanContext.op,\n      ...spanContext.attributes,\n    });\n\n    // eslint-disable-next-line deprecation/deprecation\n    this._name = spanContext.name || spanContext.description;\n\n    if (spanContext.parentSpanId) {\n      this._parentSpanId = spanContext.parentSpanId;\n    }\n    // We want to include booleans as well here\n    if ('sampled' in spanContext) {\n      this._sampled = spanContext.sampled;\n    }\n    if (spanContext.status) {\n      this._status = spanContext.status;\n    }\n    if (spanContext.endTimestamp) {\n      this._endTime = spanContext.endTimestamp;\n    }\n    if (spanContext.exclusiveTime !== undefined) {\n      this._exclusiveTime = spanContext.exclusiveTime;\n    }\n    this._measurements = spanContext.measurements ? { ...spanContext.measurements } : {};\n  }\n\n  // This rule conflicts with another eslint rule :(\n  /* eslint-disable @typescript-eslint/member-ordering */\n\n  /**\n   * An alias for `description` of the Span.\n   * @deprecated Use `spanToJSON(span).description` instead.\n   */\n  public get name(): string {\n    return this._name || '';\n  }\n\n  /**\n   * Update the name of the span.\n   * @deprecated Use `spanToJSON(span).description` instead.\n   */\n  public set name(name: string) {\n    this.updateName(name);\n  }\n\n  /**\n   * Get the description of the Span.\n   * @deprecated Use `spanToJSON(span).description` instead.\n   */\n  public get description(): string | undefined {\n    return this._name;\n  }\n\n  /**\n   * Get the description of the Span.\n   * @deprecated Use `spanToJSON(span).description` instead.\n   */\n  public set description(description: string | undefined) {\n    this._name = description;\n  }\n\n  /**\n   * The ID of the trace.\n   * @deprecated Use `spanContext().traceId` instead.\n   */\n  public get traceId(): string {\n    return this._traceId;\n  }\n\n  /**\n   * The ID of the trace.\n   * @deprecated You cannot update the traceId of a span after span creation.\n   */\n  public set traceId(traceId: string) {\n    this._traceId = traceId;\n  }\n\n  /**\n   * The ID of the span.\n   * @deprecated Use `spanContext().spanId` instead.\n   */\n  public get spanId(): string {\n    return this._spanId;\n  }\n\n  /**\n   * The ID of the span.\n   * @deprecated You cannot update the spanId of a span after span creation.\n   */\n  public set spanId(spanId: string) {\n    this._spanId = spanId;\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Use `startSpan` functions instead.\n   */\n  public set parentSpanId(string) {\n    this._parentSpanId = string;\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Use `spanToJSON(span).parent_span_id` instead.\n   */\n  public get parentSpanId(): string | undefined {\n    return this._parentSpanId;\n  }\n\n  /**\n   * Was this span chosen to be sent as part of the sample?\n   * @deprecated Use `isRecording()` instead.\n   */\n  public get sampled(): boolean | undefined {\n    return this._sampled;\n  }\n\n  /**\n   * Was this span chosen to be sent as part of the sample?\n   * @deprecated You cannot update the sampling decision of a span after span creation.\n   */\n  public set sampled(sampled: boolean | undefined) {\n    this._sampled = sampled;\n  }\n\n  /**\n   * Attributes for the span.\n   * @deprecated Use `spanToJSON(span).atttributes` instead.\n   */\n  public get attributes(): SpanAttributes {\n    return this._attributes;\n  }\n\n  /**\n   * Attributes for the span.\n   * @deprecated Use `setAttributes()` instead.\n   */\n  public set attributes(attributes: SpanAttributes) {\n    this._attributes = attributes;\n  }\n\n  /**\n   * Timestamp in seconds (epoch time) indicating when the span started.\n   * @deprecated Use `spanToJSON()` instead.\n   */\n  public get startTimestamp(): number {\n    return this._startTime;\n  }\n\n  /**\n   * Timestamp in seconds (epoch time) indicating when the span started.\n   * @deprecated In v8, you will not be able to update the span start time after creation.\n   */\n  public set startTimestamp(startTime: number) {\n    this._startTime = startTime;\n  }\n\n  /**\n   * Timestamp in seconds when the span ended.\n   * @deprecated Use `spanToJSON()` instead.\n   */\n  public get endTimestamp(): number | undefined {\n    return this._endTime;\n  }\n\n  /**\n   * Timestamp in seconds when the span ended.\n   * @deprecated Set the end time via `span.end()` instead.\n   */\n  public set endTimestamp(endTime: number | undefined) {\n    this._endTime = endTime;\n  }\n\n  /**\n   * The status of the span.\n   *\n   * @deprecated Use `spanToJSON().status` instead to get the status.\n   */\n  public get status(): SpanStatusType | string | undefined {\n    return this._status;\n  }\n\n  /**\n   * The status of the span.\n   *\n   * @deprecated Use `.setStatus()` instead to set or update the status.\n   */\n  public set status(status: SpanStatusType | string | undefined) {\n    this._status = status;\n  }\n\n  /**\n   * Operation of the span\n   *\n   * @deprecated Use `spanToJSON().op` to read the op instead.\n   */\n  public get op(): string | undefined {\n    return this._attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] as string | undefined;\n  }\n\n  /**\n   * Operation of the span\n   *\n   * @deprecated Use `startSpan()` functions to set or `span.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'op')\n   *             to update the span instead.\n   */\n  public set op(op: string | undefined) {\n    this.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, op);\n  }\n\n  /**\n   * The origin of the span, giving context about what created the span.\n   *\n   * @deprecated Use `spanToJSON().origin` to read the origin instead.\n   */\n  public get origin(): SpanOrigin | undefined {\n    return this._attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] as SpanOrigin | undefined;\n  }\n\n  /**\n   * The origin of the span, giving context about what created the span.\n   *\n   * @deprecated Use `startSpan()` functions to set the origin instead.\n   */\n  public set origin(origin: SpanOrigin | undefined) {\n    this.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, origin);\n  }\n\n  /* eslint-enable @typescript-eslint/member-ordering */\n\n  /** @inheritdoc */\n  public spanContext(): SpanContextData {\n    const { _spanId: spanId, _traceId: traceId, _sampled: sampled } = this;\n    return {\n      spanId,\n      traceId,\n      traceFlags: sampled ? TRACE_FLAG_SAMPLED : TRACE_FLAG_NONE,\n    };\n  }\n\n  /**\n   * Creates a new `Span` while setting the current `Span.id` as `parentSpanId`.\n   * Also the `sampled` decision will be inherited.\n   *\n   * @deprecated Use `startSpan()`, `startSpanManual()` or `startInactiveSpan()` instead.\n   */\n  public startChild(\n    spanContext?: Pick<SpanContext, Exclude<keyof SpanContext, 'sampled' | 'traceId' | 'parentSpanId'>>,\n  ): SpanInterface {\n    const childSpan = new Span({\n      ...spanContext,\n      parentSpanId: this._spanId,\n      sampled: this._sampled,\n      traceId: this._traceId,\n    });\n\n    // eslint-disable-next-line deprecation/deprecation\n    childSpan.spanRecorder = this.spanRecorder;\n    // eslint-disable-next-line deprecation/deprecation\n    if (childSpan.spanRecorder) {\n      // eslint-disable-next-line deprecation/deprecation\n      childSpan.spanRecorder.add(childSpan);\n    }\n\n    const rootSpan = getRootSpan(this);\n    // TODO: still set span.transaction here until we have a more permanent solution\n    // Probably similarly to the weakmap we hold in node-experimental\n    // eslint-disable-next-line deprecation/deprecation\n    childSpan.transaction = rootSpan as Transaction;\n\n    if (DEBUG_BUILD && rootSpan) {\n      const opStr = (spanContext && spanContext.op) || '< unknown op >';\n      const nameStr = spanToJSON(childSpan).description || '< unknown name >';\n      const idStr = rootSpan.spanContext().spanId;\n\n      const logMessage = `[Tracing] Starting '${opStr}' span on transaction '${nameStr}' (${idStr}).`;\n      logger.log(logMessage);\n      this._logMessage = logMessage;\n    }\n\n    return childSpan;\n  }\n\n  /**\n   * Sets the tag attribute on the current span.\n   *\n   * Can also be used to unset a tag, by passing `undefined`.\n   *\n   * @param key Tag key\n   * @param value Tag value\n   * @deprecated Use `setAttribute()` instead.\n   */\n  public setTag(key: string, value: Primitive): this {\n    // eslint-disable-next-line deprecation/deprecation\n    this.tags = { ...this.tags, [key]: value };\n    return this;\n  }\n\n  /**\n   * Sets the data attribute on the current span\n   * @param key Data key\n   * @param value Data value\n   * @deprecated Use `setAttribute()` instead.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public setData(key: string, value: any): this {\n    // eslint-disable-next-line deprecation/deprecation\n    this.data = { ...this.data, [key]: value };\n    return this;\n  }\n\n  /** @inheritdoc */\n  public setAttribute(key: string, value: SpanAttributeValue | undefined): void {\n    if (value === undefined) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete this._attributes[key];\n    } else {\n      this._attributes[key] = value;\n    }\n  }\n\n  /** @inheritdoc */\n  public setAttributes(attributes: SpanAttributes): void {\n    Object.keys(attributes).forEach(key => this.setAttribute(key, attributes[key]));\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public setStatus(value: SpanStatusType): this {\n    this._status = value;\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   * @deprecated Use top-level `setHttpStatus()` instead.\n   */\n  public setHttpStatus(httpStatus: number): this {\n    setHttpStatus(this, httpStatus);\n    return this;\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * @deprecated Use `.updateName()` instead.\n   */\n  public setName(name: string): void {\n    this.updateName(name);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public updateName(name: string): this {\n    this._name = name;\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Use `spanToJSON(span).status === 'ok'` instead.\n   */\n  public isSuccess(): boolean {\n    return this._status === 'ok';\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Use `.end()` instead.\n   */\n  public finish(endTimestamp?: number): void {\n    return this.end(endTimestamp);\n  }\n\n  /** @inheritdoc */\n  public end(endTimestamp?: SpanTimeInput): void {\n    // If already ended, skip\n    if (this._endTime) {\n      return;\n    }\n    const rootSpan = getRootSpan(this);\n    if (\n      DEBUG_BUILD &&\n      // Don't call this for transactions\n      rootSpan &&\n      rootSpan.spanContext().spanId !== this._spanId\n    ) {\n      const logMessage = this._logMessage;\n      if (logMessage) {\n        logger.log((logMessage as string).replace('Starting', 'Finishing'));\n      }\n    }\n\n    this._endTime = spanTimeInputToSeconds(endTimestamp);\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Use `spanToTraceHeader()` instead.\n   */\n  public toTraceparent(): string {\n    return spanToTraceHeader(this);\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Use `spanToJSON()` or access the fields directly instead.\n   */\n  public toContext(): SpanContext {\n    return dropUndefinedKeys({\n      data: this._getData(),\n      description: this._name,\n      endTimestamp: this._endTime,\n      // eslint-disable-next-line deprecation/deprecation\n      op: this.op,\n      parentSpanId: this._parentSpanId,\n      sampled: this._sampled,\n      spanId: this._spanId,\n      startTimestamp: this._startTime,\n      status: this._status,\n      // eslint-disable-next-line deprecation/deprecation\n      tags: this.tags,\n      traceId: this._traceId,\n    });\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Update the fields directly instead.\n   */\n  public updateWithContext(spanContext: SpanContext): this {\n    // eslint-disable-next-line deprecation/deprecation\n    this.data = spanContext.data || {};\n    // eslint-disable-next-line deprecation/deprecation\n    this._name = spanContext.name || spanContext.description;\n    this._endTime = spanContext.endTimestamp;\n    // eslint-disable-next-line deprecation/deprecation\n    this.op = spanContext.op;\n    this._parentSpanId = spanContext.parentSpanId;\n    this._sampled = spanContext.sampled;\n    this._spanId = spanContext.spanId || this._spanId;\n    this._startTime = spanContext.startTimestamp || this._startTime;\n    this._status = spanContext.status;\n    // eslint-disable-next-line deprecation/deprecation\n    this.tags = spanContext.tags || {};\n    this._traceId = spanContext.traceId || this._traceId;\n\n    return this;\n  }\n\n  /**\n   * @inheritDoc\n   *\n   * @deprecated Use `spanToTraceContext()` util function instead.\n   */\n  public getTraceContext(): TraceContext {\n    return spanToTraceContext(this);\n  }\n\n  /**\n   * Get JSON representation of this span.\n   *\n   * @hidden\n   * @internal This method is purely for internal purposes and should not be used outside\n   * of SDK code. If you need to get a JSON representation of a span,\n   * use `spanToJSON(span)` instead.\n   */\n  public getSpanJSON(): SpanJSON {\n    return dropUndefinedKeys({\n      data: this._getData(),\n      description: this._name,\n      op: this._attributes[SEMANTIC_ATTRIBUTE_SENTRY_OP] as string | undefined,\n      parent_span_id: this._parentSpanId,\n      span_id: this._spanId,\n      start_timestamp: this._startTime,\n      status: this._status,\n      // eslint-disable-next-line deprecation/deprecation\n      tags: Object.keys(this.tags).length > 0 ? this.tags : undefined,\n      timestamp: this._endTime,\n      trace_id: this._traceId,\n      origin: this._attributes[SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN] as SpanOrigin | undefined,\n      _metrics_summary: getMetricSummaryJsonForSpan(this),\n      profile_id: this._attributes[SEMANTIC_ATTRIBUTE_PROFILE_ID] as string | undefined,\n      exclusive_time: this._exclusiveTime,\n      measurements: Object.keys(this._measurements).length > 0 ? this._measurements : undefined,\n    });\n  }\n\n  /** @inheritdoc */\n  public isRecording(): boolean {\n    return !this._endTime && !!this._sampled;\n  }\n\n  /**\n   * Convert the object to JSON.\n   * @deprecated Use `spanToJSON(span)` instead.\n   */\n  public toJSON(): SpanJSON {\n    return this.getSpanJSON();\n  }\n\n  /**\n   * Get the merged data for this span.\n   * For now, this combines `data` and `attributes` together,\n   * until eventually we can ingest `attributes` directly.\n   */\n  private _getData():\n    | {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        [key: string]: any;\n      }\n    | undefined {\n    // eslint-disable-next-line deprecation/deprecation\n    const { data, _attributes: attributes } = this;\n\n    const hasData = Object.keys(data).length > 0;\n    const hasAttributes = Object.keys(attributes).length > 0;\n\n    if (!hasData && !hasAttributes) {\n      return undefined;\n    }\n\n    if (hasData && hasAttributes) {\n      return {\n        ...data,\n        ...attributes,\n      };\n    }\n\n    return hasData ? data : attributes;\n  }\n}\n","/* eslint-disable max-lines */\nimport type { IdleTransaction } from '@sentry/core';\nimport { getActiveSpan, getClient, getCurrentScope } from '@sentry/core';\nimport { getCurrentHub } from '@sentry/core';\nimport {\n  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,\n  TRACING_DEFAULTS,\n  addTracingExtensions,\n  getActiveTransaction,\n  spanToJSON,\n  startIdleTransaction,\n} from '@sentry/core';\nimport type {\n  Client,\n  Integration,\n  IntegrationFn,\n  StartSpanOptions,\n  Transaction,\n  TransactionContext,\n  TransactionSource,\n} from '@sentry/types';\nimport type { Span } from '@sentry/types';\nimport {\n  addHistoryInstrumentationHandler,\n  browserPerformanceTimeOrigin,\n  getDomElement,\n  logger,\n  propagationContextFromHeaders,\n} from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../common/debug-build';\nimport { registerBackgroundTabDetection } from './backgroundtab';\nimport { addPerformanceInstrumentationHandler } from './instrument';\nimport {\n  addPerformanceEntries,\n  startTrackingINP,\n  startTrackingInteractions,\n  startTrackingLongTasks,\n  startTrackingWebVitals,\n} from './metrics';\nimport type { RequestInstrumentationOptions } from './request';\nimport { defaultRequestInstrumentationOptions, instrumentOutgoingRequests } from './request';\nimport { WINDOW } from './types';\nimport type { InteractionRouteNameMapping } from './web-vitals/types';\n\nexport const BROWSER_TRACING_INTEGRATION_ID = 'BrowserTracing';\n\n/** Options for Browser Tracing integration */\nexport interface BrowserTracingOptions extends RequestInstrumentationOptions {\n  /**\n   * The time to wait in ms until the transaction will be finished during an idle state. An idle state is defined\n   * by a moment where there are no in-progress spans.\n   *\n   * The transaction will use the end timestamp of the last finished span as the endtime for the transaction.\n   * If there are still active spans when this the `idleTimeout` is set, the `idleTimeout` will get reset.\n   * Time is in ms.\n   *\n   * Default: 1000\n   */\n  idleTimeout: number;\n\n  /**\n   * The max duration for a transaction. If a transaction duration hits the `finalTimeout` value, it\n   * will be finished.\n   * Time is in ms.\n   *\n   * Default: 30000\n   */\n  finalTimeout: number;\n\n  /**\n   * The heartbeat interval. If no new spans are started or open spans are finished within 3 heartbeats,\n   * the transaction will be finished.\n   * Time is in ms.\n   *\n   * Default: 5000\n   */\n  heartbeatInterval: number;\n\n  /**\n   * If a span should be created on page load.\n   * If this is set to `false`, this integration will not start the default page load span.\n   * Default: true\n   */\n  instrumentPageLoad: boolean;\n\n  /**\n   * If a span should be created on navigation (history change).\n   * If this is set to `false`, this integration will not start the default navigation spans.\n   * Default: true\n   */\n  instrumentNavigation: boolean;\n\n  /**\n   * Flag spans where tabs moved to background with \"cancelled\". Browser background tab timing is\n   * not suited towards doing precise measurements of operations. By default, we recommend that this option\n   * be enabled as background transactions can mess up your statistics in nondeterministic ways.\n   *\n   * Default: true\n   */\n  markBackgroundSpan: boolean;\n\n  /**\n   * If true, Sentry will capture long tasks and add them to the corresponding transaction.\n   *\n   * Default: true\n   */\n  enableLongTask: boolean;\n\n  /**\n   * If true, Sentry will capture INP web vitals as standalone spans .\n   *\n   * Default: false\n   */\n  enableInp: boolean;\n\n  /**\n   * Sample rate to determine interaction span sampling.\n   * interactionsSampleRate is applied on top of the global tracesSampleRate.\n   * ie a tracesSampleRate of 0.1 and interactionsSampleRate of 0.5 will result in a 0.05 sample rate for interactions.\n   *\n   * Default: 1\n   */\n  interactionsSampleRate: number;\n\n  /**\n   * _metricOptions allows the user to send options to change how metrics are collected.\n   *\n   * _metricOptions is currently experimental.\n   *\n   * Default: undefined\n   */\n  _metricOptions?: Partial<{\n    /**\n     * @deprecated This property no longer has any effect and will be removed in v8.\n     */\n    _reportAllChanges: boolean;\n  }>;\n\n  /**\n   * _experiments allows the user to send options to define how this integration works.\n   * Note that the `enableLongTask` options is deprecated in favor of the option at the top level, and will be removed in v8.\n   *\n   * TODO (v8): Remove enableLongTask\n   *\n   * Default: undefined\n   */\n  _experiments: Partial<{\n    enableInteractions: boolean;\n  }>;\n\n  /**\n   * A callback which is called before a span for a pageload or navigation is started.\n   * It receives the options passed to `startSpan`, and expects to return an updated options object.\n   */\n  beforeStartSpan?: (options: StartSpanOptions) => StartSpanOptions;\n}\n\nconst DEFAULT_BROWSER_TRACING_OPTIONS: BrowserTracingOptions = {\n  ...TRACING_DEFAULTS,\n  instrumentNavigation: true,\n  instrumentPageLoad: true,\n  markBackgroundSpan: true,\n  enableLongTask: true,\n  enableInp: false,\n  interactionsSampleRate: 1,\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. This integration uses {@see IdleTransaction} to create transactions.\n *\n * We explicitly export the proper type here, as this has to be extended in some cases.\n */\nexport const browserTracingIntegration = ((_options: Partial<BrowserTracingOptions> = {}) => {\n  const _hasSetTracePropagationTargets = DEBUG_BUILD\n    ? !!(\n        // eslint-disable-next-line deprecation/deprecation\n        (_options.tracePropagationTargets || _options.tracingOrigins)\n      )\n    : false;\n\n  addTracingExtensions();\n\n  // TODO (v8): remove this block after tracingOrigins is removed\n  // Set tracePropagationTargets to tracingOrigins if specified by the user\n  // In case both are specified, tracePropagationTargets takes precedence\n  // eslint-disable-next-line deprecation/deprecation\n  if (!_options.tracePropagationTargets && _options.tracingOrigins) {\n    // eslint-disable-next-line deprecation/deprecation\n    _options.tracePropagationTargets = _options.tracingOrigins;\n  }\n\n  const options = {\n    ...DEFAULT_BROWSER_TRACING_OPTIONS,\n    ..._options,\n  };\n\n  const _collectWebVitals = startTrackingWebVitals();\n\n  /** Stores a mapping of interactionIds from PerformanceEventTimings to the origin interaction path */\n  const interactionIdToRouteNameMapping: InteractionRouteNameMapping = {};\n  if (options.enableInp) {\n    startTrackingINP(interactionIdToRouteNameMapping, options.interactionsSampleRate);\n  }\n\n  if (options.enableLongTask) {\n    startTrackingLongTasks();\n  }\n  if (options._experiments.enableInteractions) {\n    startTrackingInteractions();\n  }\n\n  const latestRoute: {\n    name: string | undefined;\n    context: TransactionContext | undefined;\n  } = {\n    name: undefined,\n    context: undefined,\n  };\n\n  /** Create routing idle transaction. */\n  function _createRouteTransaction(context: TransactionContext): Transaction | undefined {\n    // eslint-disable-next-line deprecation/deprecation\n    const hub = getCurrentHub();\n\n    const { beforeStartSpan, idleTimeout, finalTimeout, heartbeatInterval } = options;\n\n    const isPageloadTransaction = context.op === 'pageload';\n\n    let expandedContext: TransactionContext;\n    if (isPageloadTransaction) {\n      const sentryTrace = isPageloadTransaction ? getMetaContent('sentry-trace') : '';\n      const baggage = isPageloadTransaction ? getMetaContent('baggage') : undefined;\n      const { traceId, dsc, parentSpanId, sampled } = propagationContextFromHeaders(sentryTrace, baggage);\n      expandedContext = {\n        traceId,\n        parentSpanId,\n        parentSampled: sampled,\n        ...context,\n        metadata: {\n          // eslint-disable-next-line deprecation/deprecation\n          ...context.metadata,\n          dynamicSamplingContext: dsc,\n        },\n        trimEnd: true,\n      };\n    } else {\n      expandedContext = {\n        trimEnd: true,\n        ...context,\n      };\n    }\n\n    const finalContext = beforeStartSpan ? beforeStartSpan(expandedContext) : expandedContext;\n\n    // If `beforeStartSpan` set a custom name, record that fact\n    // eslint-disable-next-line deprecation/deprecation\n    finalContext.metadata =\n      finalContext.name !== expandedContext.name\n        ? // eslint-disable-next-line deprecation/deprecation\n          { ...finalContext.metadata, source: 'custom' }\n        : // eslint-disable-next-line deprecation/deprecation\n          finalContext.metadata;\n\n    latestRoute.name = finalContext.name;\n    latestRoute.context = finalContext;\n\n    if (finalContext.sampled === false) {\n      DEBUG_BUILD && logger.log(`[Tracing] Will not send ${finalContext.op} transaction because of beforeNavigate.`);\n    }\n\n    DEBUG_BUILD && logger.log(`[Tracing] Starting ${finalContext.op} transaction on scope`);\n\n    const { location } = WINDOW;\n\n    const idleTransaction = startIdleTransaction(\n      hub,\n      finalContext,\n      idleTimeout,\n      finalTimeout,\n      true,\n      { location }, // for use in the tracesSampler\n      heartbeatInterval,\n      isPageloadTransaction, // should wait for finish signal if it's a pageload transaction\n    );\n\n    if (isPageloadTransaction && WINDOW.document) {\n      WINDOW.document.addEventListener('readystatechange', () => {\n        if (['interactive', 'complete'].includes(WINDOW.document!.readyState)) {\n          idleTransaction.sendAutoFinishSignal();\n        }\n      });\n\n      if (['interactive', 'complete'].includes(WINDOW.document.readyState)) {\n        idleTransaction.sendAutoFinishSignal();\n      }\n    }\n\n    idleTransaction.registerBeforeFinishCallback(transaction => {\n      _collectWebVitals();\n      addPerformanceEntries(transaction);\n    });\n\n    return idleTransaction as Transaction;\n  }\n\n  return {\n    name: BROWSER_TRACING_INTEGRATION_ID,\n    // eslint-disable-next-line @typescript-eslint/no-empty-function\n    setupOnce: () => {},\n    afterAllSetup(client) {\n      const clientOptions = client.getOptions();\n\n      const { markBackgroundSpan, traceFetch, traceXHR, shouldCreateSpanForRequest, enableHTTPTimings, _experiments } =\n        options;\n\n      const clientOptionsTracePropagationTargets = clientOptions && clientOptions.tracePropagationTargets;\n      // There are three ways to configure tracePropagationTargets:\n      // 1. via top level client option `tracePropagationTargets`\n      // 2. via BrowserTracing option `tracePropagationTargets`\n      // 3. via BrowserTracing option `tracingOrigins` (deprecated)\n      //\n      // To avoid confusion, favour top level client option `tracePropagationTargets`, and fallback to\n      // BrowserTracing option `tracePropagationTargets` and then `tracingOrigins` (deprecated).\n      // This is done as it minimizes bundle size (we don't have to have undefined checks).\n      //\n      // If both 1 and either one of 2 or 3 are set (from above), we log out a warning.\n      // eslint-disable-next-line deprecation/deprecation\n      const tracePropagationTargets = clientOptionsTracePropagationTargets || options.tracePropagationTargets;\n      if (DEBUG_BUILD && _hasSetTracePropagationTargets && clientOptionsTracePropagationTargets) {\n        logger.warn(\n          '[Tracing] The `tracePropagationTargets` option was set in the BrowserTracing integration and top level `Sentry.init`. The top level `Sentry.init` value is being used.',\n        );\n      }\n\n      let activeSpan: Span | undefined;\n      let startingUrl: string | undefined = WINDOW.location && WINDOW.location.href;\n\n      if (client.on) {\n        client.on('startNavigationSpan', (context: StartSpanOptions) => {\n          if (activeSpan) {\n            DEBUG_BUILD && logger.log(`[Tracing] Finishing current transaction with op: ${spanToJSON(activeSpan).op}`);\n            // If there's an open transaction on the scope, we need to finish it before creating an new one.\n            activeSpan.end();\n          }\n          activeSpan = _createRouteTransaction({\n            op: 'navigation',\n            ...context,\n          });\n        });\n\n        client.on('startPageLoadSpan', (context: StartSpanOptions) => {\n          if (activeSpan) {\n            DEBUG_BUILD && logger.log(`[Tracing] Finishing current transaction with op: ${spanToJSON(activeSpan).op}`);\n            // If there's an open transaction on the scope, we need to finish it before creating an new one.\n            activeSpan.end();\n          }\n          activeSpan = _createRouteTransaction({\n            op: 'pageload',\n            ...context,\n          });\n        });\n      }\n\n      if (options.instrumentPageLoad && client.emit && WINDOW.location) {\n        const context: StartSpanOptions = {\n          name: WINDOW.location.pathname,\n          // pageload should always start at timeOrigin (and needs to be in s, not ms)\n          startTimestamp: browserPerformanceTimeOrigin ? browserPerformanceTimeOrigin / 1000 : undefined,\n          origin: 'auto.pageload.browser',\n          attributes: {\n            [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',\n          },\n        };\n        startBrowserTracingPageLoadSpan(client, context);\n      }\n\n      if (options.instrumentNavigation && client.emit && WINDOW.location) {\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 && startingUrl.indexOf(to) !== -1) {\n            startingUrl = undefined;\n            return;\n          }\n\n          if (from !== to) {\n            startingUrl = undefined;\n            const context: StartSpanOptions = {\n              name: WINDOW.location.pathname,\n              origin: 'auto.navigation.browser',\n              attributes: {\n                [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: 'url',\n              },\n            };\n\n            startBrowserTracingNavigationSpan(client, context);\n          }\n        });\n      }\n\n      if (markBackgroundSpan) {\n        registerBackgroundTabDetection();\n      }\n\n      if (_experiments.enableInteractions) {\n        registerInteractionListener(options, latestRoute);\n      }\n\n      if (options.enableInp) {\n        registerInpInteractionListener(interactionIdToRouteNameMapping, latestRoute);\n      }\n\n      instrumentOutgoingRequests({\n        traceFetch,\n        traceXHR,\n        tracePropagationTargets,\n        shouldCreateSpanForRequest,\n        enableHTTPTimings,\n      });\n    },\n    // TODO v8: Remove this again\n    // This is private API that we use to fix converted BrowserTracing integrations in Next.js & SvelteKit\n    options,\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Manually start a page load span.\n * This will only do something if the BrowserTracing integration has been setup.\n */\nexport function startBrowserTracingPageLoadSpan(client: Client, spanOptions: StartSpanOptions): Span | undefined {\n  if (!client.emit) {\n    return;\n  }\n\n  client.emit('startPageLoadSpan', spanOptions);\n\n  const span = getActiveSpan();\n  const op = span && spanToJSON(span).op;\n  return op === 'pageload' ? span : undefined;\n}\n\n/**\n * Manually start a navigation span.\n * This will only do something if the BrowserTracing integration has been setup.\n */\nexport function startBrowserTracingNavigationSpan(client: Client, spanOptions: StartSpanOptions): Span | undefined {\n  if (!client.emit) {\n    return;\n  }\n\n  client.emit('startNavigationSpan', spanOptions);\n\n  const span = getActiveSpan();\n  const op = span && spanToJSON(span).op;\n  return op === 'navigation' ? span : undefined;\n}\n\n/** Returns the value of a meta tag */\nexport function getMetaContent(metaName: string): string | undefined {\n  // Can't specify generic to `getDomElement` because tracing can be used\n  // in a variety of environments, have to disable `no-unsafe-member-access`\n  // as a result.\n  const metaTag = getDomElement(`meta[name=${metaName}]`);\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return metaTag ? metaTag.getAttribute('content') : undefined;\n}\n\n/** Start listener for interaction transactions */\nfunction registerInteractionListener(\n  options: BrowserTracingOptions,\n  latestRoute: {\n    name: string | undefined;\n    context: TransactionContext | undefined;\n  },\n): void {\n  let inflightInteractionTransaction: IdleTransaction | undefined;\n  const registerInteractionTransaction = (): void => {\n    const { idleTimeout, finalTimeout, heartbeatInterval } = options;\n    const op = 'ui.action.click';\n\n    // eslint-disable-next-line deprecation/deprecation\n    const currentTransaction = getActiveTransaction();\n    if (currentTransaction && currentTransaction.op && ['navigation', 'pageload'].includes(currentTransaction.op)) {\n      DEBUG_BUILD &&\n        logger.warn(\n          `[Tracing] Did not create ${op} transaction because a pageload or navigation transaction is in progress.`,\n        );\n      return undefined;\n    }\n\n    if (inflightInteractionTransaction) {\n      inflightInteractionTransaction.setFinishReason('interactionInterrupted');\n      inflightInteractionTransaction.end();\n      inflightInteractionTransaction = 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    const { location } = WINDOW;\n\n    const context: TransactionContext = {\n      name: latestRoute.name,\n      op,\n      trimEnd: true,\n      data: {\n        [SEMANTIC_ATTRIBUTE_SENTRY_SOURCE]: latestRoute.context ? getSource(latestRoute.context) : undefined || 'url',\n      },\n    };\n\n    inflightInteractionTransaction = startIdleTransaction(\n      // eslint-disable-next-line deprecation/deprecation\n      getCurrentHub(),\n      context,\n      idleTimeout,\n      finalTimeout,\n      true,\n      { location }, // for use in the tracesSampler\n      heartbeatInterval,\n    );\n  };\n\n  ['click'].forEach(type => {\n    if (WINDOW.document) {\n      addEventListener(type, registerInteractionTransaction, { once: false, capture: true });\n    }\n  });\n}\n\nfunction isPerformanceEventTiming(entry: PerformanceEntry): entry is PerformanceEventTiming {\n  return 'duration' in entry;\n}\n\n/** We store up to 10 interaction candidates max to cap memory usage. This is the same cap as getINP from web-vitals */\nconst MAX_INTERACTIONS = 10;\n\n/** Creates a listener on interaction entries, and maps interactionIds to the origin path of the interaction */\nfunction registerInpInteractionListener(\n  interactionIdToRouteNameMapping: InteractionRouteNameMapping,\n  latestRoute: {\n    name: string | undefined;\n    context: TransactionContext | undefined;\n  },\n): void {\n  const handleEntries = ({ entries }: { entries: PerformanceEntry[] }): void => {\n    const client = getClient();\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 =\n      client !== undefined && client.getIntegrationByName !== undefined\n        ? (client.getIntegrationByName('Replay') as Integration & { getReplayId: () => string })\n        : undefined;\n    const replayId = replay !== undefined ? replay.getReplayId() : undefined;\n    // eslint-disable-next-line deprecation/deprecation\n    const activeTransaction = getActiveTransaction();\n    const currentScope = getCurrentScope();\n    const user = currentScope !== undefined ? currentScope.getUser() : undefined;\n    entries.forEach(entry => {\n      if (isPerformanceEventTiming(entry)) {\n        const interactionId = entry.interactionId;\n        if (interactionId === undefined) {\n          return;\n        }\n        const existingInteraction = interactionIdToRouteNameMapping[interactionId];\n        const duration = entry.duration;\n        const startTime = entry.startTime;\n        const keys = Object.keys(interactionIdToRouteNameMapping);\n        const minInteractionId =\n          keys.length > 0\n            ? keys.reduce((a, b) => {\n                return interactionIdToRouteNameMapping[a].duration < interactionIdToRouteNameMapping[b].duration\n                  ? a\n                  : b;\n              })\n            : undefined;\n        // For a first input event to be considered, we must check that an interaction event does not already exist with the same duration and start time.\n        // This is also checked in the web-vitals library.\n        if (entry.entryType === 'first-input') {\n          const matchingEntry = keys\n            .map(key => interactionIdToRouteNameMapping[key])\n            .some(interaction => {\n              return interaction.duration === duration && interaction.startTime === startTime;\n            });\n          if (matchingEntry) {\n            return;\n          }\n        }\n        // Interactions with an id of 0 and are not first-input are not valid.\n        if (!interactionId) {\n          return;\n        }\n        // If the interaction already exists, we want to use the duration of the longest entry, since that is what the INP metric uses.\n        if (existingInteraction) {\n          existingInteraction.duration = Math.max(existingInteraction.duration, duration);\n        } else if (\n          keys.length < MAX_INTERACTIONS ||\n          minInteractionId === undefined ||\n          duration > interactionIdToRouteNameMapping[minInteractionId].duration\n        ) {\n          // If the interaction does not exist, we want to add it to the mapping if there is space, or if the duration is longer than the shortest entry.\n          const routeName = latestRoute.name;\n          const parentContext = latestRoute.context;\n          if (routeName && parentContext) {\n            if (minInteractionId && Object.keys(interactionIdToRouteNameMapping).length >= MAX_INTERACTIONS) {\n              // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n              delete interactionIdToRouteNameMapping[minInteractionId];\n            }\n            interactionIdToRouteNameMapping[interactionId] = {\n              routeName,\n              duration,\n              parentContext,\n              user,\n              activeTransaction,\n              replayId,\n              startTime,\n            };\n          }\n        }\n      }\n    });\n  };\n  addPerformanceInstrumentationHandler('event', handleEntries);\n  addPerformanceInstrumentationHandler('first-input', handleEntries);\n}\n\nfunction getSource(context: TransactionContext): TransactionSource | undefined {\n  const sourceFromAttributes = context.attributes && context.attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];\n  // eslint-disable-next-line deprecation/deprecation\n  const sourceFromData = context.data && context.data[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];\n  // eslint-disable-next-line deprecation/deprecation\n  const sourceFromMetadata = context.metadata && context.metadata.source;\n\n  return sourceFromAttributes || sourceFromData || sourceFromMetadata;\n}\n","import { DEBUG_BUILD } from './debug-build';\nimport { logger } from './logger';\nimport { getGlobalObject } from './worldwide';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject<Window>();\n\ndeclare const EdgeRuntime: string | undefined;\n\nexport { supportsHistory } from './vendor/supportsHistory';\n\n/**\n * Tells whether current environment supports ErrorEvent objects\n * {@link supportsErrorEvent}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsErrorEvent(): boolean {\n  try {\n    new ErrorEvent('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMError objects\n * {@link supportsDOMError}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMError(): boolean {\n  try {\n    // Chrome: VM89:1 Uncaught TypeError: Failed to construct 'DOMError':\n    // 1 argument required, but only 0 present.\n    // @ts-expect-error It really needs 1 argument, not 0.\n    new DOMError('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports DOMException objects\n * {@link supportsDOMException}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsDOMException(): boolean {\n  try {\n    new DOMException('');\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Tells whether current environment supports Fetch API\n * {@link supportsFetch}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsFetch(): boolean {\n  if (!('fetch' in WINDOW)) {\n    return false;\n  }\n\n  try {\n    new Headers();\n    new Request('http://www.example.com');\n    new Response();\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n/**\n * isNativeFetch checks if the given function is a native implementation of fetch()\n */\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport function isNativeFetch(func: Function): boolean {\n  return func && /^function fetch\\(\\)\\s+\\{\\s+\\[native code\\]\\s+\\}$/.test(func.toString());\n}\n\n/**\n * Tells whether current environment supports Fetch API natively\n * {@link supportsNativeFetch}.\n *\n * @returns true if `window.fetch` is natively implemented, false otherwise\n */\nexport function supportsNativeFetch(): boolean {\n  if (typeof EdgeRuntime === 'string') {\n    return true;\n  }\n\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  // Fast path to avoid DOM I/O\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  if (isNativeFetch(WINDOW.fetch)) {\n    return true;\n  }\n\n  // window.fetch is implemented, but is polyfilled or already wrapped (e.g: by a chrome extension)\n  // so create a \"pure\" iframe to see if that has native fetch\n  let result = false;\n  const doc = WINDOW.document;\n  // eslint-disable-next-line deprecation/deprecation\n  if (doc && typeof (doc.createElement as unknown) === 'function') {\n    try {\n      const sandbox = doc.createElement('iframe');\n      sandbox.hidden = true;\n      doc.head.appendChild(sandbox);\n      if (sandbox.contentWindow && sandbox.contentWindow.fetch) {\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        result = isNativeFetch(sandbox.contentWindow.fetch);\n      }\n      doc.head.removeChild(sandbox);\n    } catch (err) {\n      DEBUG_BUILD &&\n        logger.warn('Could not create sandbox iframe for pure fetch check, bailing to window.fetch: ', err);\n    }\n  }\n\n  return result;\n}\n\n/**\n * Tells whether current environment supports ReportingObserver API\n * {@link supportsReportingObserver}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReportingObserver(): boolean {\n  return 'ReportingObserver' in WINDOW;\n}\n\n/**\n * Tells whether current environment supports Referrer Policy API\n * {@link supportsReferrerPolicy}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsReferrerPolicy(): boolean {\n  // Despite all stars in the sky saying that Edge supports old draft syntax, aka 'never', 'always', 'origin' and 'default'\n  // (see https://caniuse.com/#feat=referrer-policy),\n  // it doesn't. And it throws an exception instead of ignoring this parameter...\n  // REF: https://github.com/getsentry/raven-js/issues/1233\n\n  if (!supportsFetch()) {\n    return false;\n  }\n\n  try {\n    new Request('_', {\n      referrerPolicy: 'origin' as ReferrerPolicy,\n    });\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n","import type { Hub } from '@sentry/core';\nimport { functionToStringIntegration, inboundFiltersIntegration } from '@sentry/core';\nimport {\n  captureSession,\n  getClient,\n  getCurrentHub,\n  getIntegrationsToSetup,\n  getReportDialogEndpoint,\n  initAndBind,\n  startSession,\n} from '@sentry/core';\nimport type { Integration, Options, UserFeedback } from '@sentry/types';\nimport {\n  addHistoryInstrumentationHandler,\n  logger,\n  stackParserFromStackParserOptions,\n  supportsFetch,\n} from '@sentry/utils';\n\nimport type { BrowserClientOptions, BrowserOptions } from './client';\nimport { BrowserClient } from './client';\nimport { DEBUG_BUILD } from './debug-build';\nimport type { ReportDialogOptions } from './helpers';\nimport { WINDOW, wrap as internalWrap } from './helpers';\nimport { breadcrumbsIntegration } from './integrations/breadcrumbs';\nimport { dedupeIntegration } from './integrations/dedupe';\nimport { globalHandlersIntegration } from './integrations/globalhandlers';\nimport { httpContextIntegration } from './integrations/httpcontext';\nimport { linkedErrorsIntegration } from './integrations/linkederrors';\nimport { browserApiErrorsIntegration } from './integrations/trycatch';\nimport { defaultStackParser } from './stack-parsers';\nimport { makeFetchTransport, makeXHRTransport } from './transports';\n\n/** @deprecated Use `getDefaultIntegrations(options)` instead. */\nexport const defaultIntegrations = [\n  inboundFiltersIntegration(),\n  functionToStringIntegration(),\n  browserApiErrorsIntegration(),\n  breadcrumbsIntegration(),\n  globalHandlersIntegration(),\n  linkedErrorsIntegration(),\n  dedupeIntegration(),\n  httpContextIntegration(),\n];\n\n/** Get the default integrations for the browser SDK. */\nexport function getDefaultIntegrations(_options: Options): Integration[] {\n  // We return a copy of the defaultIntegrations here to avoid mutating this\n  return [\n    // eslint-disable-next-line deprecation/deprecation\n    ...defaultIntegrations,\n  ];\n}\n\n/**\n * A magic string that build tooling can leverage in order to inject a release value into the SDK.\n */\ndeclare const __SENTRY_RELEASE__: string | undefined;\n\n/**\n * The Sentry Browser SDK Client.\n *\n * To use this SDK, call the {@link init} function as early as possible when\n * loading the web page. To set context information or send manual events, use\n * the provided methods.\n *\n * @example\n *\n * ```\n *\n * import { init } from '@sentry/browser';\n *\n * init({\n *   dsn: '__DSN__',\n *   // ...\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { configureScope } from '@sentry/browser';\n * configureScope((scope: Scope) => {\n *   scope.setExtra({ battery: 0.7 });\n *   scope.setTag({ user_mode: 'admin' });\n *   scope.setUser({ id: '4711' });\n * });\n * ```\n *\n * @example\n * ```\n *\n * import { addBreadcrumb } from '@sentry/browser';\n * addBreadcrumb({\n *   message: 'My Breadcrumb',\n *   // ...\n * });\n * ```\n *\n * @example\n *\n * ```\n *\n * import * as Sentry from '@sentry/browser';\n * Sentry.captureMessage('Hello, world!');\n * Sentry.captureException(new Error('Good bye'));\n * Sentry.captureEvent({\n *   message: 'Manual',\n *   stacktrace: [\n *     // ...\n *   ],\n * });\n * ```\n *\n * @see {@link BrowserOptions} for documentation on configuration options.\n */\nexport function init(options: BrowserOptions = {}): void {\n  if (options.defaultIntegrations === undefined) {\n    options.defaultIntegrations = getDefaultIntegrations(options);\n  }\n  if (options.release === undefined) {\n    // This allows build tooling to find-and-replace __SENTRY_RELEASE__ to inject a release value\n    if (typeof __SENTRY_RELEASE__ === 'string') {\n      options.release = __SENTRY_RELEASE__;\n    }\n\n    // This supports the variable that sentry-webpack-plugin injects\n    if (WINDOW.SENTRY_RELEASE && WINDOW.SENTRY_RELEASE.id) {\n      options.release = WINDOW.SENTRY_RELEASE.id;\n    }\n  }\n  if (options.autoSessionTracking === undefined) {\n    options.autoSessionTracking = true;\n  }\n  if (options.sendClientReports === undefined) {\n    options.sendClientReports = true;\n  }\n\n  const clientOptions: BrowserClientOptions = {\n    ...options,\n    stackParser: stackParserFromStackParserOptions(options.stackParser || defaultStackParser),\n    integrations: getIntegrationsToSetup(options),\n    transport: options.transport || (supportsFetch() ? makeFetchTransport : makeXHRTransport),\n  };\n\n  initAndBind(BrowserClient, clientOptions);\n\n  if (options.autoSessionTracking) {\n    startSessionTracking();\n  }\n}\n\ntype NewReportDialogOptions = ReportDialogOptions & { eventId: string }; // eslint-disable-line\n\ninterface ShowReportDialogFunction {\n  /**\n   * Present the user with a report dialog.\n   *\n   * @param options Everything is optional, we try to fetch all info need from the global scope.\n   */\n  (options: NewReportDialogOptions): void;\n\n  /**\n   * Present the user with a report dialog.\n   *\n   * @param options Everything is optional, we try to fetch all info need from the global scope.\n   *\n   * @deprecated Please always pass an `options` argument with `eventId`. The `hub` argument will not be used in the next version of the SDK.\n   */\n  // eslint-disable-next-line deprecation/deprecation\n  (options?: ReportDialogOptions, hub?: Hub): void;\n}\n\nexport const showReportDialog: ShowReportDialogFunction = (\n  // eslint-disable-next-line deprecation/deprecation\n  options: ReportDialogOptions = {},\n  // eslint-disable-next-line deprecation/deprecation\n  hub: Hub = getCurrentHub(),\n) => {\n  // doesn't work without a document (React Native)\n  if (!WINDOW.document) {\n    DEBUG_BUILD && logger.error('Global document not defined in showReportDialog call');\n    return;\n  }\n\n  // eslint-disable-next-line deprecation/deprecation\n  const { client, scope } = hub.getStackTop();\n  const dsn = options.dsn || (client && client.getDsn());\n  if (!dsn) {\n    DEBUG_BUILD && logger.error('DSN not configured for showReportDialog call');\n    return;\n  }\n\n  if (scope) {\n    options.user = {\n      ...scope.getUser(),\n      ...options.user,\n    };\n  }\n\n  if (!options.eventId) {\n    // eslint-disable-next-line deprecation/deprecation\n    options.eventId = hub.lastEventId();\n  }\n\n  const script = WINDOW.document.createElement('script');\n  script.async = true;\n  script.crossOrigin = 'anonymous';\n  script.src = getReportDialogEndpoint(dsn, options);\n\n  if (options.onLoad) {\n    script.onload = options.onLoad;\n  }\n\n  const { onClose } = options;\n  if (onClose) {\n    const reportDialogClosedMessageHandler = (event: MessageEvent): void => {\n      if (event.data === '__sentry_reportdialog_closed__') {\n        try {\n          onClose();\n        } finally {\n          WINDOW.removeEventListener('message', reportDialogClosedMessageHandler);\n        }\n      }\n    };\n    WINDOW.addEventListener('message', reportDialogClosedMessageHandler);\n  }\n\n  const injectionPoint = WINDOW.document.head || WINDOW.document.body;\n  if (injectionPoint) {\n    injectionPoint.appendChild(script);\n  } else {\n    DEBUG_BUILD && logger.error('Not injecting report dialog. No injection point found in HTML');\n  }\n};\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function forceLoad(): void {\n  // Noop\n}\n\n/**\n * This function is here to be API compatible with the loader.\n * @hidden\n */\nexport function onLoad(callback: () => void): void {\n  callback();\n}\n\n/**\n * Wrap code within a try/catch block so the SDK is able to capture errors.\n *\n * @deprecated This function will be removed in v8.\n * It is not part of Sentry's official API and it's easily replaceable by using a try/catch block\n * and calling Sentry.captureException.\n *\n * @param fn A function to wrap.\n *\n * @returns The result of wrapped function call.\n */\n// TODO(v8): Remove this function\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function wrap(fn: (...args: any) => any): any {\n  return internalWrap(fn)();\n}\n\n/**\n * Enable automatic Session Tracking for the initial page load.\n */\nfunction startSessionTracking(): void {\n  if (typeof WINDOW.document === 'undefined') {\n    DEBUG_BUILD && logger.warn('Session tracking in non-browser environment with @sentry/browser is not supported.');\n    return;\n  }\n\n  // The session duration for browser sessions does not track a meaningful\n  // concept that can be used as a metric.\n  // Automatically captured sessions are akin to page views, and thus we\n  // discard their duration.\n  startSession({ ignoreDuration: true });\n  captureSession();\n\n  // We want to create a session for every navigation as well\n  addHistoryInstrumentationHandler(({ from, to }) => {\n    // Don't create an additional session for the initial route or if the location did not change\n    if (from !== undefined && from !== to) {\n      startSession({ ignoreDuration: true });\n      captureSession();\n    }\n  });\n}\n\n/**\n * Captures user feedback and sends it to Sentry.\n */\nexport function captureUserFeedback(feedback: UserFeedback): void {\n  const client = getClient<BrowserClient>();\n  if (client) {\n    client.captureUserFeedback(feedback);\n  }\n}\n","/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.\n *\n * Note: This file was originally called `global.ts`, but was changed to unblock users which might be doing\n * string replaces with bundlers like Vite for `global` (would break imports that rely on importing from utils/src/global).\n *\n * Why worldwide?\n *\n * Why not?\n */\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { Integration } from '@sentry/types';\n\nimport type { SdkSource } from './env';\n\n/** Internal global with common properties and Sentry extensions  */\nexport interface InternalGlobal {\n  navigator?: { userAgent?: string };\n  console: Console;\n  Sentry?: {\n    Integrations?: Integration[];\n  };\n  onerror?: {\n    (event: object | string, source?: string, lineno?: number, colno?: number, error?: Error): any;\n    __SENTRY_INSTRUMENTED__?: true;\n    __SENTRY_LOADER__?: true;\n  };\n  onunhandledrejection?: {\n    (event: unknown): boolean;\n    __SENTRY_INSTRUMENTED__?: true;\n    __SENTRY_LOADER__?: true;\n  };\n  SENTRY_ENVIRONMENT?: string;\n  SENTRY_DSN?: string;\n  SENTRY_RELEASE?: {\n    id?: string;\n  };\n  SENTRY_SDK_SOURCE?: SdkSource;\n  /**\n   * Debug IDs are indirectly injected by Sentry CLI or bundler plugins to directly reference a particular source map\n   * for resolving of a source file. The injected code will place an entry into the record for each loaded bundle/JS\n   * file.\n   */\n  _sentryDebugIds?: Record<string, string>;\n  __SENTRY__: {\n    globalEventProcessors: any;\n    hub: any;\n    logger: any;\n    extensions?: {\n      /** Extension methods for the hub, which are bound to the current Hub instance */\n      // eslint-disable-next-line @typescript-eslint/ban-types\n      [key: string]: Function;\n    };\n  };\n  /**\n   * Raw module metadata that is injected by bundler plugins.\n   *\n   * Keys are `error.stack` strings, values are the metadata.\n   */\n  _sentryModuleMetadata?: Record<string, any>;\n}\n\n// The code below for 'isGlobalObj' and 'GLOBAL_OBJ' was copied from core-js before modification\n// https://github.com/zloirock/core-js/blob/1b944df55282cdc99c90db5f49eb0b6eda2cc0a3/packages/core-js/internals/global.js\n// core-js has the following licence:\n//\n// Copyright (c) 2014-2022 Denis Pushkarev\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n/** Returns 'obj' if it's the global object, otherwise returns undefined */\nfunction isGlobalObj(obj: { Math?: Math }): any | undefined {\n  return obj && obj.Math == Math ? obj : undefined;\n}\n\n/** Get's the global object for the current JavaScript runtime */\nexport const GLOBAL_OBJ: InternalGlobal =\n  (typeof globalThis == 'object' && isGlobalObj(globalThis)) ||\n  // eslint-disable-next-line no-restricted-globals\n  (typeof window == 'object' && isGlobalObj(window)) ||\n  (typeof self == 'object' && isGlobalObj(self)) ||\n  (typeof global == 'object' && isGlobalObj(global)) ||\n  (function (this: any) {\n    return this;\n  })() ||\n  {};\n\n/**\n * @deprecated Use GLOBAL_OBJ instead or WINDOW from @sentry/browser. This will be removed in v8\n */\nexport function getGlobalObject<T>(): T & InternalGlobal {\n  return GLOBAL_OBJ as T & InternalGlobal;\n}\n\n/**\n * Returns a global singleton contained in the global `__SENTRY__` object.\n *\n * If the singleton doesn't already exist in `__SENTRY__`, it will be created using the given factory\n * function and added to the `__SENTRY__` object.\n *\n * @param name name of the global singleton on __SENTRY__\n * @param creator creator Factory function to create the singleton if it doesn't already exist on `__SENTRY__`\n * @param obj (Optional) The global object on which to look for `__SENTRY__`, if not `GLOBAL_OBJ`'s return value\n * @returns the singleton\n */\nexport function getGlobalSingleton<T>(name: keyof InternalGlobal['__SENTRY__'], creator: () => T, obj?: unknown): T {\n  const gbl = (obj || GLOBAL_OBJ) as InternalGlobal;\n  const __SENTRY__ = (gbl.__SENTRY__ = gbl.__SENTRY__ || {});\n  const singleton = __SENTRY__[name] || (__SENTRY__[name] = creator());\n  return singleton;\n}\n","import type { DsnComponents, DsnLike, DsnProtocol } from '@sentry/types';\n\nimport { DEBUG_BUILD } from './debug-build';\nimport { consoleSandbox, logger } from './logger';\n\n/** Regular expression used to parse a Dsn. */\nconst DSN_REGEX = /^(?:(\\w+):)\\/\\/(?:(\\w+)(?::(\\w+)?)?@)([\\w.-]+)(?::(\\d+))?\\/(.+)/;\n\nfunction isValidProtocol(protocol?: string): protocol is DsnProtocol {\n  return protocol === 'http' || protocol === 'https';\n}\n\n/**\n * Renders the string representation of this Dsn.\n *\n * By default, this will render the public representation without the password\n * component. To get the deprecated private representation, set `withPassword`\n * to true.\n *\n * @param withPassword When set to true, the password will be included.\n */\nexport function dsnToString(dsn: DsnComponents, withPassword: boolean = false): string {\n  const { host, path, pass, port, projectId, protocol, publicKey } = dsn;\n  return (\n    `${protocol}://${publicKey}${withPassword && pass ? `:${pass}` : ''}` +\n    `@${host}${port ? `:${port}` : ''}/${path ? `${path}/` : path}${projectId}`\n  );\n}\n\n/**\n * Parses a Dsn from a given string.\n *\n * @param str A Dsn as string\n * @returns Dsn as DsnComponents or undefined if @param str is not a valid DSN string\n */\nexport function dsnFromString(str: string): DsnComponents | undefined {\n  const match = DSN_REGEX.exec(str);\n\n  if (!match) {\n    // This should be logged to the console\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.error(`Invalid Sentry Dsn: ${str}`);\n    });\n    return undefined;\n  }\n\n  const [protocol, publicKey, pass = '', host, port = '', lastPath] = match.slice(1);\n  let path = '';\n  let projectId = lastPath;\n\n  const split = projectId.split('/');\n  if (split.length > 1) {\n    path = split.slice(0, -1).join('/');\n    projectId = split.pop() as string;\n  }\n\n  if (projectId) {\n    const projectMatch = projectId.match(/^\\d+/);\n    if (projectMatch) {\n      projectId = projectMatch[0];\n    }\n  }\n\n  return dsnFromComponents({ host, pass, path, projectId, port, protocol: protocol as DsnProtocol, publicKey });\n}\n\nfunction dsnFromComponents(components: DsnComponents): DsnComponents {\n  return {\n    protocol: components.protocol,\n    publicKey: components.publicKey || '',\n    pass: components.pass || '',\n    host: components.host,\n    port: components.port || '',\n    path: components.path || '',\n    projectId: components.projectId,\n  };\n}\n\nfunction validateDsn(dsn: DsnComponents): boolean {\n  if (!DEBUG_BUILD) {\n    return true;\n  }\n\n  const { port, projectId, protocol } = dsn;\n\n  const requiredComponents: ReadonlyArray<keyof DsnComponents> = ['protocol', 'publicKey', 'host', 'projectId'];\n  const hasMissingRequiredComponent = requiredComponents.find(component => {\n    if (!dsn[component]) {\n      logger.error(`Invalid Sentry Dsn: ${component} missing`);\n      return true;\n    }\n    return false;\n  });\n\n  if (hasMissingRequiredComponent) {\n    return false;\n  }\n\n  if (!projectId.match(/^\\d+$/)) {\n    logger.error(`Invalid Sentry Dsn: Invalid projectId ${projectId}`);\n    return false;\n  }\n\n  if (!isValidProtocol(protocol)) {\n    logger.error(`Invalid Sentry Dsn: Invalid protocol ${protocol}`);\n    return false;\n  }\n\n  if (port && isNaN(parseInt(port, 10))) {\n    logger.error(`Invalid Sentry Dsn: Invalid port ${port}`);\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Creates a valid Sentry Dsn object, identifying a Sentry instance and project.\n * @returns a valid DsnComponents object or `undefined` if @param from is an invalid DSN source\n */\nexport function makeDsn(from: DsnLike): DsnComponents | undefined {\n  const components = typeof from === 'string' ? dsnFromString(from) : dsnFromComponents(from);\n  if (!components || !validateDsn(components)) {\n    return undefined;\n  }\n  return components;\n}\n","import type {\n  Client,\n  Event,\n  EventHint,\n  Integration,\n  IntegrationClass,\n  IntegrationFn,\n  IntegrationFnResult,\n  Options,\n} from '@sentry/types';\nimport { arrayify, logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from './debug-build';\nimport { addGlobalEventProcessor } from './eventProcessors';\nimport { getClient } from './exports';\nimport { getCurrentHub } from './hub';\n\ndeclare module '@sentry/types' {\n  interface Integration {\n    isDefaultInstance?: boolean;\n  }\n}\n\nexport const installedIntegrations: string[] = [];\n\n/** Map of integrations assigned to a client */\nexport type IntegrationIndex = {\n  [key: string]: Integration;\n};\n\n/**\n * Remove duplicates from the given array, preferring the last instance of any duplicate. Not guaranteed to\n * preseve the order of integrations in the array.\n *\n * @private\n */\nfunction filterDuplicates(integrations: Integration[]): Integration[] {\n  const integrationsByName: { [key: string]: Integration } = {};\n\n  integrations.forEach(currentInstance => {\n    const { name } = currentInstance;\n\n    const existingInstance = integrationsByName[name];\n\n    // We want integrations later in the array to overwrite earlier ones of the same type, except that we never want a\n    // default instance to overwrite an existing user instance\n    if (existingInstance && !existingInstance.isDefaultInstance && currentInstance.isDefaultInstance) {\n      return;\n    }\n\n    integrationsByName[name] = currentInstance;\n  });\n\n  return Object.keys(integrationsByName).map(k => integrationsByName[k]);\n}\n\n/** Gets integrations to install */\nexport function getIntegrationsToSetup(options: Pick<Options, 'defaultIntegrations' | 'integrations'>): Integration[] {\n  const defaultIntegrations = options.defaultIntegrations || [];\n  const userIntegrations = options.integrations;\n\n  // We flag default instances, so that later we can tell them apart from any user-created instances of the same class\n  defaultIntegrations.forEach(integration => {\n    integration.isDefaultInstance = true;\n  });\n\n  let integrations: Integration[];\n\n  if (Array.isArray(userIntegrations)) {\n    integrations = [...defaultIntegrations, ...userIntegrations];\n  } else if (typeof userIntegrations === 'function') {\n    integrations = arrayify(userIntegrations(defaultIntegrations));\n  } else {\n    integrations = defaultIntegrations;\n  }\n\n  const finalIntegrations = filterDuplicates(integrations);\n\n  // The `Debug` integration prints copies of the `event` and `hint` which will be passed to `beforeSend` or\n  // `beforeSendTransaction`. It therefore has to run after all other integrations, so that the changes of all event\n  // processors will be reflected in the printed values. For lack of a more elegant way to guarantee that, we therefore\n  // locate it and, assuming it exists, pop it out of its current spot and shove it onto the end of the array.\n  const debugIndex = findIndex(finalIntegrations, integration => integration.name === 'Debug');\n  if (debugIndex !== -1) {\n    const [debugInstance] = finalIntegrations.splice(debugIndex, 1);\n    finalIntegrations.push(debugInstance);\n  }\n\n  return finalIntegrations;\n}\n\n/**\n * Given a list of integration instances this installs them all. When `withDefaults` is set to `true` then all default\n * integrations are added unless they were already provided before.\n * @param integrations array of integration instances\n * @param withDefault should enable default integrations\n */\nexport function setupIntegrations(client: Client, integrations: Integration[]): IntegrationIndex {\n  const integrationIndex: IntegrationIndex = {};\n\n  integrations.forEach(integration => {\n    // guard against empty provided integrations\n    if (integration) {\n      setupIntegration(client, integration, integrationIndex);\n    }\n  });\n\n  return integrationIndex;\n}\n\n/**\n * Execute the `afterAllSetup` hooks of the given integrations.\n */\nexport function afterSetupIntegrations(client: Client, integrations: Integration[]): void {\n  for (const integration of integrations) {\n    // guard against empty provided integrations\n    if (integration && integration.afterAllSetup) {\n      integration.afterAllSetup(client);\n    }\n  }\n}\n\n/** Setup a single integration.  */\nexport function setupIntegration(client: Client, integration: Integration, integrationIndex: IntegrationIndex): void {\n  if (integrationIndex[integration.name]) {\n    DEBUG_BUILD && logger.log(`Integration skipped because it was already installed: ${integration.name}`);\n    return;\n  }\n  integrationIndex[integration.name] = integration;\n\n  // `setupOnce` is only called the first time\n  if (installedIntegrations.indexOf(integration.name) === -1) {\n    // eslint-disable-next-line deprecation/deprecation\n    integration.setupOnce(addGlobalEventProcessor, getCurrentHub);\n    installedIntegrations.push(integration.name);\n  }\n\n  // `setup` is run for each client\n  if (integration.setup && typeof integration.setup === 'function') {\n    integration.setup(client);\n  }\n\n  if (client.on && typeof integration.preprocessEvent === 'function') {\n    const callback = integration.preprocessEvent.bind(integration) as typeof integration.preprocessEvent;\n    client.on('preprocessEvent', (event, hint) => callback(event, hint, client));\n  }\n\n  if (client.addEventProcessor && typeof integration.processEvent === 'function') {\n    const callback = integration.processEvent.bind(integration) as typeof integration.processEvent;\n\n    const processor = Object.assign((event: Event, hint: EventHint) => callback(event, hint, client), {\n      id: integration.name,\n    });\n\n    client.addEventProcessor(processor);\n  }\n\n  DEBUG_BUILD && logger.log(`Integration installed: ${integration.name}`);\n}\n\n/** Add an integration to the current hub's client. */\nexport function addIntegration(integration: Integration): void {\n  const client = getClient();\n\n  if (!client || !client.addIntegration) {\n    DEBUG_BUILD && logger.warn(`Cannot add integration \"${integration.name}\" because no SDK Client is available.`);\n    return;\n  }\n\n  client.addIntegration(integration);\n}\n\n// Polyfill for Array.findIndex(), which is not supported in ES5\nfunction findIndex<T>(arr: T[], callback: (item: T) => boolean): number {\n  for (let i = 0; i < arr.length; i++) {\n    if (callback(arr[i]) === true) {\n      return i;\n    }\n  }\n\n  return -1;\n}\n\n/**\n * Convert a new integration function to the legacy class syntax.\n * In v8, we can remove this and instead export the integration functions directly.\n *\n * @deprecated This will be removed in v8!\n */\nexport function convertIntegrationFnToClass<Fn extends IntegrationFn>(\n  name: string,\n  fn: Fn,\n): IntegrationClass<Integration> {\n  return Object.assign(\n    function ConvertedIntegration(...args: Parameters<Fn>): Integration {\n      return fn(...args);\n    },\n    { id: name },\n  ) as unknown as IntegrationClass<Integration>;\n}\n\n/**\n * Define an integration function that can be used to create an integration instance.\n * Note that this by design hides the implementation details of the integration, as they are considered internal.\n */\nexport function defineIntegration<Fn extends IntegrationFn>(fn: Fn): (...args: Parameters<Fn>) => IntegrationFnResult {\n  return fn;\n}\n","import type { Event, EventHint, Exception, ExtendedError, StackParser } from '@sentry/types';\n\nimport { isInstanceOf } from './is';\nimport { truncate } from './string';\n\n/**\n * Creates exceptions inside `event.exception.values` for errors that are nested on properties based on the `key` parameter.\n */\nexport function applyAggregateErrorsToEvent(\n  exceptionFromErrorImplementation: (stackParser: StackParser, ex: Error) => Exception,\n  parser: StackParser,\n  maxValueLimit: number = 250,\n  key: string,\n  limit: number,\n  event: Event,\n  hint?: EventHint,\n): void {\n  if (!event.exception || !event.exception.values || !hint || !isInstanceOf(hint.originalException, Error)) {\n    return;\n  }\n\n  // Generally speaking the last item in `event.exception.values` is the exception originating from the original Error\n  const originalException: Exception | undefined =\n    event.exception.values.length > 0 ? event.exception.values[event.exception.values.length - 1] : undefined;\n\n  // We only create exception grouping if there is an exception in the event.\n  if (originalException) {\n    event.exception.values = truncateAggregateExceptions(\n      aggregateExceptionsFromError(\n        exceptionFromErrorImplementation,\n        parser,\n        limit,\n        hint.originalException as ExtendedError,\n        key,\n        event.exception.values,\n        originalException,\n        0,\n      ),\n      maxValueLimit,\n    );\n  }\n}\n\nfunction aggregateExceptionsFromError(\n  exceptionFromErrorImplementation: (stackParser: StackParser, ex: Error) => Exception,\n  parser: StackParser,\n  limit: number,\n  error: ExtendedError,\n  key: string,\n  prevExceptions: Exception[],\n  exception: Exception,\n  exceptionId: number,\n): Exception[] {\n  if (prevExceptions.length >= limit + 1) {\n    return prevExceptions;\n  }\n\n  let newExceptions = [...prevExceptions];\n\n  // Recursively call this function in order to walk down a chain of errors\n  if (isInstanceOf(error[key], Error)) {\n    applyExceptionGroupFieldsForParentException(exception, exceptionId);\n    const newException = exceptionFromErrorImplementation(parser, error[key]);\n    const newExceptionId = newExceptions.length;\n    applyExceptionGroupFieldsForChildException(newException, key, newExceptionId, exceptionId);\n    newExceptions = aggregateExceptionsFromError(\n      exceptionFromErrorImplementation,\n      parser,\n      limit,\n      error[key],\n      key,\n      [newException, ...newExceptions],\n      newException,\n      newExceptionId,\n    );\n  }\n\n  // This will create exception grouping for AggregateErrors\n  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AggregateError\n  if (Array.isArray(error.errors)) {\n    error.errors.forEach((childError, i) => {\n      if (isInstanceOf(childError, Error)) {\n        applyExceptionGroupFieldsForParentException(exception, exceptionId);\n        const newException = exceptionFromErrorImplementation(parser, childError);\n        const newExceptionId = newExceptions.length;\n        applyExceptionGroupFieldsForChildException(newException, `errors[${i}]`, newExceptionId, exceptionId);\n        newExceptions = aggregateExceptionsFromError(\n          exceptionFromErrorImplementation,\n          parser,\n          limit,\n          childError,\n          key,\n          [newException, ...newExceptions],\n          newException,\n          newExceptionId,\n        );\n      }\n    });\n  }\n\n  return newExceptions;\n}\n\nfunction applyExceptionGroupFieldsForParentException(exception: Exception, exceptionId: number): void {\n  // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.\n  exception.mechanism = exception.mechanism || { type: 'generic', handled: true };\n\n  exception.mechanism = {\n    ...exception.mechanism,\n    ...(exception.type === 'AggregateError' && { is_exception_group: true }),\n    exception_id: exceptionId,\n  };\n}\n\nfunction applyExceptionGroupFieldsForChildException(\n  exception: Exception,\n  source: string,\n  exceptionId: number,\n  parentId: number | undefined,\n): void {\n  // Don't know if this default makes sense. The protocol requires us to set these values so we pick *some* default.\n  exception.mechanism = exception.mechanism || { type: 'generic', handled: true };\n\n  exception.mechanism = {\n    ...exception.mechanism,\n    type: 'chained',\n    source,\n    exception_id: exceptionId,\n    parent_id: parentId,\n  };\n}\n\n/**\n * Truncate the message (exception.value) of all exceptions in the event.\n * Because this event processor is ran after `applyClientOptions`,\n * we need to truncate the message of the added exceptions here.\n */\nfunction truncateAggregateExceptions(exceptions: Exception[], maxValueLength: number): Exception[] {\n  return exceptions.map(exception => {\n    if (exception.value) {\n      exception.value = truncate(exception.value, maxValueLength);\n    }\n    return exception;\n  });\n}\n","import type { Client, Integration, IntegrationClass, IntegrationFn, WrappedFunction } from '@sentry/types';\nimport { getOriginalFunction } from '@sentry/utils';\nimport { getClient } from '../exports';\nimport { convertIntegrationFnToClass, defineIntegration } from '../integration';\n\nlet originalFunctionToString: () => void;\n\nconst INTEGRATION_NAME = 'FunctionToString';\n\nconst SETUP_CLIENTS = new WeakMap<Client, boolean>();\n\nconst _functionToStringIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      // eslint-disable-next-line @typescript-eslint/unbound-method\n      originalFunctionToString = Function.prototype.toString;\n\n      // intrinsics (like Function.prototype) might be immutable in some environments\n      // e.g. Node with --frozen-intrinsics, XS (an embedded JavaScript engine) or SES (a JavaScript proposal)\n      try {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        Function.prototype.toString = function (this: WrappedFunction, ...args: any[]): string {\n          const originalFunction = getOriginalFunction(this);\n          const context =\n            SETUP_CLIENTS.has(getClient() as Client) && originalFunction !== undefined ? originalFunction : this;\n          return originalFunctionToString.apply(context, args);\n        };\n      } catch {\n        // ignore errors here, just don't patch this\n      }\n    },\n    setup(client) {\n      SETUP_CLIENTS.set(client, true);\n    },\n  };\n}) satisfies IntegrationFn;\n\n/**\n * Patch toString calls to return proper name for wrapped functions.\n *\n * ```js\n * Sentry.init({\n *   integrations: [\n *     functionToStringIntegration(),\n *   ],\n * });\n * ```\n */\nexport const functionToStringIntegration = defineIntegration(_functionToStringIntegration);\n\n/**\n * Patch toString calls to return proper name for wrapped functions.\n *\n * @deprecated Use `functionToStringIntegration()` instead.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport const FunctionToString = convertIntegrationFnToClass(\n  INTEGRATION_NAME,\n  functionToStringIntegration,\n) as IntegrationClass<Integration & { setupOnce: () => void }>;\n\n// eslint-disable-next-line deprecation/deprecation\nexport type FunctionToString = typeof FunctionToString;\n","import {\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  getClient,\n  getCurrentScope,\n  getDynamicSamplingContextFromClient,\n  getDynamicSamplingContextFromSpan,\n  getIsolationScope,\n  hasTracingEnabled,\n  setHttpStatus,\n  spanToTraceHeader,\n  startInactiveSpan,\n} from '@sentry/core';\nimport type { Client, HandlerDataFetch, Scope, Span, SpanOrigin } from '@sentry/types';\nimport {\n  BAGGAGE_HEADER_NAME,\n  dynamicSamplingContextToSentryBaggageHeader,\n  generateSentryTraceHeader,\n  isInstanceOf,\n  parseUrl,\n} from '@sentry/utils';\n\ntype PolymorphicRequestHeaders =\n  | Record<string, string | undefined>\n  | Array<[string, string]>\n  // the below is not preicsely the Header type used in Request, but it'll pass duck-typing\n  | {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      [key: string]: any;\n      append: (key: string, value: string) => void;\n      get: (key: string) => string | null | undefined;\n    };\n\n/**\n * Create and track fetch request spans for usage in combination with `addInstrumentationHandler`.\n *\n * @returns Span if a span was created, otherwise void.\n */\nexport function instrumentFetchRequest(\n  handlerData: HandlerDataFetch,\n  shouldCreateSpan: (url: string) => boolean,\n  shouldAttachHeaders: (url: string) => boolean,\n  spans: Record<string, Span>,\n  spanOrigin: SpanOrigin = 'auto.http.browser',\n): Span | undefined {\n  if (!hasTracingEnabled() || !handlerData.fetchData) {\n    return undefined;\n  }\n\n  const shouldCreateSpanResult = 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      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete spans[spanId];\n    }\n    return undefined;\n  }\n\n  const scope = getCurrentScope();\n  const client = getClient();\n\n  const { method, url } = handlerData.fetchData;\n\n  const fullUrl = getFullURL(url);\n  const host = fullUrl ? parseUrl(fullUrl).host : undefined;\n\n  const span = shouldCreateSpanResult\n    ? startInactiveSpan({\n        name: `${method} ${url}`,\n        onlyIfParent: true,\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        },\n        op: 'http.client',\n      })\n    : undefined;\n\n  if (span) {\n    handlerData.fetchData.__span = span.spanContext().spanId;\n    spans[span.spanContext().spanId] = span;\n  }\n\n  if (shouldAttachHeaders(handlerData.fetchData.url) && client) {\n    const request: string | Request = handlerData.args[0];\n\n    // In case the user hasn't set the second argument of a fetch call we default it to `{}`.\n    handlerData.args[1] = handlerData.args[1] || {};\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const options: { [key: string]: any } = handlerData.args[1];\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access\n    options.headers = addTracingHeadersToFetchRequest(request, client, scope, options, span);\n  }\n\n  return span;\n}\n\n/**\n * Adds sentry-trace and baggage headers to the various forms of fetch headers\n */\nexport function addTracingHeadersToFetchRequest(\n  request: string | unknown, // unknown is actually type Request but we can't export DOM types from this package,\n  client: Client,\n  scope: Scope,\n  options: {\n    headers?:\n      | {\n          [key: string]: string[] | string | undefined;\n        }\n      | PolymorphicRequestHeaders;\n  },\n  requestSpan?: Span,\n): PolymorphicRequestHeaders | undefined {\n  // eslint-disable-next-line deprecation/deprecation\n  const span = requestSpan || scope.getSpan();\n\n  const isolationScope = getIsolationScope();\n\n  const { traceId, spanId, sampled, dsc } = {\n    ...isolationScope.getPropagationContext(),\n    ...scope.getPropagationContext(),\n  };\n\n  const sentryTraceHeader = span ? spanToTraceHeader(span) : generateSentryTraceHeader(traceId, spanId, sampled);\n\n  const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(\n    dsc ||\n      (span ? getDynamicSamplingContextFromSpan(span) : getDynamicSamplingContextFromClient(traceId, client, scope)),\n  );\n\n  const headers =\n    options.headers ||\n    (typeof Request !== 'undefined' && isInstanceOf(request, Request) ? (request as Request).headers : undefined);\n\n  if (!headers) {\n    return { 'sentry-trace': sentryTraceHeader, baggage: sentryBaggageHeader };\n  } else if (typeof Headers !== 'undefined' && isInstanceOf(headers, Headers)) {\n    const newHeaders = new Headers(headers as Headers);\n\n    newHeaders.append('sentry-trace', sentryTraceHeader);\n\n    if (sentryBaggageHeader) {\n      // If the same header is appended multiple times the browser will merge the values into a single request header.\n      // Its therefore safe to simply push a \"baggage\" entry, even though there might already be another baggage header.\n      newHeaders.append(BAGGAGE_HEADER_NAME, sentryBaggageHeader);\n    }\n\n    return newHeaders as PolymorphicRequestHeaders;\n  } else if (Array.isArray(headers)) {\n    const newHeaders = [...headers, ['sentry-trace', sentryTraceHeader]];\n\n    if (sentryBaggageHeader) {\n      // If there are multiple entries with the same key, the browser will merge the values into a single request header.\n      // Its therefore safe to simply push a \"baggage\" entry, even though there might already be another baggage header.\n      newHeaders.push([BAGGAGE_HEADER_NAME, sentryBaggageHeader]);\n    }\n\n    return newHeaders as PolymorphicRequestHeaders;\n  } else {\n    const existingBaggageHeader = 'baggage' in headers ? headers.baggage : undefined;\n    const newBaggageHeaders: string[] = [];\n\n    if (Array.isArray(existingBaggageHeader)) {\n      newBaggageHeaders.push(...existingBaggageHeader);\n    } else if (existingBaggageHeader) {\n      newBaggageHeaders.push(existingBaggageHeader);\n    }\n\n    if (sentryBaggageHeader) {\n      newBaggageHeaders.push(sentryBaggageHeader);\n    }\n\n    return {\n      ...(headers as Exclude<typeof headers, Headers>),\n      'sentry-trace': sentryTraceHeader,\n      baggage: newBaggageHeaders.length > 0 ? newBaggageHeaders.join(',') : undefined,\n    };\n  }\n}\n\nfunction getFullURL(url: string): string | undefined {\n  try {\n    const parsed = new URL(url);\n    return parsed.href;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction endSpan(span: Span, handlerData: HandlerDataFetch): void {\n  if (handlerData.response) {\n    setHttpStatus(span, handlerData.response.status);\n\n    const contentLength =\n      handlerData.response && handlerData.response.headers && handlerData.response.headers.get('content-length');\n\n    if (contentLength) {\n      const contentLengthNum = parseInt(contentLength);\n      if (contentLengthNum > 0) {\n        span.setAttribute('http.response_content_length', contentLengthNum);\n      }\n    }\n  } else if (handlerData.error) {\n    span.setStatus('internal_error');\n  }\n  span.end();\n}\n","/* eslint-disable max-lines */\nimport {\n  SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,\n  getClient,\n  getCurrentScope,\n  getDynamicSamplingContextFromClient,\n  getDynamicSamplingContextFromSpan,\n  getIsolationScope,\n  hasTracingEnabled,\n  setHttpStatus,\n  spanToJSON,\n  spanToTraceHeader,\n  startInactiveSpan,\n} from '@sentry/core';\nimport type { HandlerDataXhr, SentryWrappedXMLHttpRequest, Span } from '@sentry/types';\nimport {\n  BAGGAGE_HEADER_NAME,\n  SENTRY_XHR_DATA_KEY,\n  addFetchInstrumentationHandler,\n  addXhrInstrumentationHandler,\n  browserPerformanceTimeOrigin,\n  dynamicSamplingContextToSentryBaggageHeader,\n  generateSentryTraceHeader,\n  parseUrl,\n  stringMatchesSomePattern,\n} from '@sentry/utils';\n\nimport { instrumentFetchRequest } from '../common/fetch';\nimport { addPerformanceInstrumentationHandler } from './instrument';\nimport { WINDOW } from './types';\n\nexport const DEFAULT_TRACE_PROPAGATION_TARGETS = ['localhost', /^\\/(?!\\/)/];\n\n/** Options for Request Instrumentation */\nexport interface RequestInstrumentationOptions {\n  /**\n   * @deprecated Will be removed in v8.\n   * Use `shouldCreateSpanForRequest` to control span creation and `tracePropagationTargets` to control\n   * trace header attachment.\n   */\n  tracingOrigins: Array<string | RegExp>;\n\n  /**\n   * List of strings and/or regexes used to determine which outgoing requests will have `sentry-trace` and `baggage`\n   * headers attached.\n   *\n   * @deprecated Use the top-level `tracePropagationTargets` option in `Sentry.init` instead.\n   * This option will be removed in v8.\n   *\n   * Default: ['localhost', /^\\//] @see {DEFAULT_TRACE_PROPAGATION_TARGETS}\n   */\n  tracePropagationTargets: Array<string | RegExp>;\n\n  /**\n   * Flag to disable patching all together for fetch requests.\n   *\n   * Default: true\n   */\n  traceFetch: boolean;\n\n  /**\n   * Flag to disable patching all together for xhr requests.\n   *\n   * Default: true\n   */\n  traceXHR: boolean;\n\n  /**\n   * If true, Sentry will capture http timings and add them to the corresponding http spans.\n   *\n   * Default: true\n   */\n  enableHTTPTimings: boolean;\n\n  /**\n   * This function will be called before creating a span for a request with the given url.\n   * Return false if you don't want a span for the given url.\n   *\n   * Default: (url: string) => true\n   */\n  shouldCreateSpanForRequest?(this: void, url: string): boolean;\n}\n\nexport const defaultRequestInstrumentationOptions: RequestInstrumentationOptions = {\n  traceFetch: true,\n  traceXHR: true,\n  enableHTTPTimings: true,\n  // TODO (v8): Remove this property\n  tracingOrigins: DEFAULT_TRACE_PROPAGATION_TARGETS,\n  tracePropagationTargets: DEFAULT_TRACE_PROPAGATION_TARGETS,\n};\n\n/** Registers span creators for xhr and fetch requests  */\nexport function instrumentOutgoingRequests(_options?: Partial<RequestInstrumentationOptions>): void {\n  const {\n    traceFetch,\n    traceXHR,\n    // eslint-disable-next-line deprecation/deprecation\n    tracePropagationTargets,\n    // eslint-disable-next-line deprecation/deprecation\n    tracingOrigins,\n    shouldCreateSpanForRequest,\n    enableHTTPTimings,\n  } = {\n    traceFetch: defaultRequestInstrumentationOptions.traceFetch,\n    traceXHR: defaultRequestInstrumentationOptions.traceXHR,\n    ..._options,\n  };\n\n  const shouldCreateSpan =\n    typeof shouldCreateSpanForRequest === 'function' ? shouldCreateSpanForRequest : (_: string) => true;\n\n  // TODO(v8) Remove tracingOrigins here\n  // The only reason we're passing it in here is because this instrumentOutgoingRequests function is publicly exported\n  // and we don't want to break the API. We can remove it in v8.\n  const shouldAttachHeadersWithTargets = (url: string): boolean =>\n    shouldAttachHeaders(url, tracePropagationTargets || tracingOrigins);\n\n  const spans: Record<string, Span> = {};\n\n  if (traceFetch) {\n    addFetchInstrumentationHandler(handlerData => {\n      const createdSpan = instrumentFetchRequest(handlerData, shouldCreateSpan, shouldAttachHeadersWithTargets, spans);\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: PerformanceEntry): entry is PerformanceResourceTiming {\n  return (\n    entry.entryType === 'resource' &&\n    'initiatorType' in entry &&\n    typeof (entry as PerformanceResourceTiming).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: Span): void {\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\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 */\nexport function extractNetworkProtocol(nextHopProtocol: string): { name: string; version: string } {\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\nfunction getAbsoluteTime(time: number = 0): number {\n  return ((browserPerformanceTimeOrigin || performance.timeOrigin) + time) / 1000;\n}\n\nfunction resourceTimingEntryToSpanData(resourceTiming: PerformanceResourceTiming): [string, string | number][] {\n  const { name, version } = extractNetworkProtocol(resourceTiming.nextHopProtocol);\n\n  const timingSpanData: [string, string | number][] = [];\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 * This was extracted from `instrumentOutgoingRequests` to make it easier to test shouldAttachHeaders.\n * We only export this fuction for testing purposes.\n */\nexport function shouldAttachHeaders(url: string, tracePropagationTargets: (string | RegExp)[] | undefined): boolean {\n  return stringMatchesSomePattern(url, tracePropagationTargets || DEFAULT_TRACE_PROPAGATION_TARGETS);\n}\n\n/**\n * Create and track xhr request spans\n *\n * @returns Span if a span was created, otherwise void.\n */\n// eslint-disable-next-line complexity\nexport function xhrCallback(\n  handlerData: HandlerDataXhr,\n  shouldCreateSpan: (url: string) => boolean,\n  shouldAttachHeaders: (url: string) => boolean,\n  spans: Record<string, Span>,\n): Span | undefined {\n  const xhr = handlerData.xhr;\n  const sentryXhrData = xhr && xhr[SENTRY_XHR_DATA_KEY];\n\n  if (!hasTracingEnabled() || !xhr || xhr.__sentry_own_request__ || !sentryXhrData) {\n    return undefined;\n  }\n\n  const shouldCreateSpanResult = 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 scope = getCurrentScope();\n  const isolationScope = getIsolationScope();\n\n  const fullUrl = getFullURL(sentryXhrData.url);\n  const host = fullUrl ? parseUrl(fullUrl).host : undefined;\n\n  const span = shouldCreateSpanResult\n    ? startInactiveSpan({\n        name: `${sentryXhrData.method} ${sentryXhrData.url}`,\n        onlyIfParent: true,\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        },\n        op: 'http.client',\n      })\n    : undefined;\n\n  if (span) {\n    xhr.__sentry_xhr_span_id__ = span.spanContext().spanId;\n    spans[xhr.__sentry_xhr_span_id__] = span;\n  }\n\n  const client = getClient();\n\n  if (xhr.setRequestHeader && shouldAttachHeaders(sentryXhrData.url) && client) {\n    const { traceId, spanId, sampled, dsc } = {\n      ...isolationScope.getPropagationContext(),\n      ...scope.getPropagationContext(),\n    };\n\n    const sentryTraceHeader = span ? spanToTraceHeader(span) : generateSentryTraceHeader(traceId, spanId, sampled);\n\n    const sentryBaggageHeader = dynamicSamplingContextToSentryBaggageHeader(\n      dsc ||\n        (span ? getDynamicSamplingContextFromSpan(span) : getDynamicSamplingContextFromClient(traceId, client, scope)),\n    );\n\n    setHeaderOnXhr(xhr, sentryTraceHeader, sentryBaggageHeader);\n  }\n\n  return span;\n}\n\nfunction setHeaderOnXhr(\n  xhr: SentryWrappedXMLHttpRequest,\n  sentryTraceHeader: string,\n  sentryBaggageHeader: string | undefined,\n): void {\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_HEADER_NAME, 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: string): string | undefined {\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","declare const __DEBUG_BUILD__: boolean;\n\n/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nexport const DEBUG_BUILD = __DEBUG_BUILD__;\n","import { isNodeEnv } from './node';\nimport { GLOBAL_OBJ } from './worldwide';\n\n/**\n * Returns true if we are in the browser.\n */\nexport function isBrowser(): boolean {\n  // eslint-disable-next-line no-restricted-globals\n  return typeof window !== 'undefined' && (!isNodeEnv() || isElectronNodeRenderer());\n}\n\ntype ElectronProcess = { type?: string };\n\n// Electron renderers with nodeIntegration enabled are detected as Node.js so we specifically test for them\nfunction isElectronNodeRenderer(): boolean {\n  return (\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any\n    (GLOBAL_OBJ as any).process !== undefined && ((GLOBAL_OBJ as any).process as ElectronProcess).type === 'renderer'\n  );\n}\n","import type { Client, ClientOptions } from '@sentry/types';\nimport { consoleSandbox, logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from './debug-build';\nimport { getCurrentScope } from './exports';\nimport { getCurrentHub } from './hub';\n\n/** A class object that can instantiate Client objects. */\nexport type ClientClass<F extends Client, O extends ClientOptions> = new (options: O) => F;\n\n/**\n * Internal function to create a new SDK client instance. The client is\n * installed and then bound to the current scope.\n *\n * @param clientClass The client class to instantiate.\n * @param options Options to pass to the client.\n */\nexport function initAndBind<F extends Client, O extends ClientOptions>(\n  clientClass: ClientClass<F, O>,\n  options: O,\n): void {\n  if (options.debug === true) {\n    if (DEBUG_BUILD) {\n      logger.enable();\n    } else {\n      // use `console.warn` rather than `logger.warn` since by non-debug bundles have all `logger.x` statements stripped\n      consoleSandbox(() => {\n        // eslint-disable-next-line no-console\n        console.warn('[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.');\n      });\n    }\n  }\n  const scope = getCurrentScope();\n  scope.update(options.initialScope);\n\n  const client = new clientClass(options);\n  setCurrentClient(client);\n  initializeClient(client);\n}\n\n/**\n * Make the given client the current client.\n */\nexport function setCurrentClient(client: Client): void {\n  // eslint-disable-next-line deprecation/deprecation\n  const hub = getCurrentHub();\n  // eslint-disable-next-line deprecation/deprecation\n  const top = hub.getStackTop();\n  top.client = client;\n  top.scope.setClient(client);\n}\n\n/**\n * Initialize the client for the current scope.\n * Make sure to call this after `setCurrentClient()`.\n */\nfunction initializeClient(client: Client): void {\n  if (client.init) {\n    client.init();\n    // TODO v8: Remove this fallback\n    // eslint-disable-next-line deprecation/deprecation\n  } else if (client.setupIntegrations) {\n    // eslint-disable-next-line deprecation/deprecation\n    client.setupIntegrations();\n  }\n}\n","import { isRegExp, isString, isVueViewModel } from './is';\n\nexport { escapeStringForRegex } from './vendor/escapeStringForRegex';\n\n/**\n * Truncates given string to the maximum characters count\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string (0 = unlimited)\n * @returns string Encoded\n */\nexport function truncate(str: string, max: number = 0): string {\n  if (typeof str !== 'string' || max === 0) {\n    return str;\n  }\n  return str.length <= max ? str : `${str.slice(0, max)}...`;\n}\n\n/**\n * This is basically just `trim_line` from\n * https://github.com/getsentry/sentry/blob/master/src/sentry/lang/javascript/processor.py#L67\n *\n * @param str An object that contains serializable values\n * @param max Maximum number of characters in truncated string\n * @returns string Encoded\n */\nexport function snipLine(line: string, colno: number): string {\n  let newLine = line;\n  const lineLength = newLine.length;\n  if (lineLength <= 150) {\n    return newLine;\n  }\n  if (colno > lineLength) {\n    // eslint-disable-next-line no-param-reassign\n    colno = lineLength;\n  }\n\n  let start = Math.max(colno - 60, 0);\n  if (start < 5) {\n    start = 0;\n  }\n\n  let end = Math.min(start + 140, lineLength);\n  if (end > lineLength - 5) {\n    end = lineLength;\n  }\n  if (end === lineLength) {\n    start = Math.max(end - 140, 0);\n  }\n\n  newLine = newLine.slice(start, end);\n  if (start > 0) {\n    newLine = `'{snip} ${newLine}`;\n  }\n  if (end < lineLength) {\n    newLine += ' {snip}';\n  }\n\n  return newLine;\n}\n\n/**\n * Join values in array\n * @param input array of values to be joined together\n * @param delimiter string to be placed in-between values\n * @returns Joined values\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function safeJoin(input: any[], delimiter?: string): string {\n  if (!Array.isArray(input)) {\n    return '';\n  }\n\n  const output = [];\n  // eslint-disable-next-line @typescript-eslint/prefer-for-of\n  for (let i = 0; i < input.length; i++) {\n    const value = input[i];\n    try {\n      // This is a hack to fix a Vue3-specific bug that causes an infinite loop of\n      // console warnings. This happens when a Vue template is rendered with\n      // an undeclared variable, which we try to stringify, ultimately causing\n      // Vue to issue another warning which repeats indefinitely.\n      // see: https://github.com/getsentry/sentry-javascript/pull/8981\n      if (isVueViewModel(value)) {\n        output.push('[VueViewModel]');\n      } else {\n        output.push(String(value));\n      }\n    } catch (e) {\n      output.push('[value cannot be serialized]');\n    }\n  }\n\n  return output.join(delimiter);\n}\n\n/**\n * Checks if the given value matches a regex or string\n *\n * @param value The string to test\n * @param pattern Either a regex or a string against which `value` will be matched\n * @param requireExactStringMatch If true, `value` must match `pattern` exactly. If false, `value` will match\n * `pattern` if it contains `pattern`. Only applies to string-type patterns.\n */\nexport function isMatchingPattern(\n  value: string,\n  pattern: RegExp | string,\n  requireExactStringMatch: boolean = false,\n): boolean {\n  if (!isString(value)) {\n    return false;\n  }\n\n  if (isRegExp(pattern)) {\n    return pattern.test(value);\n  }\n  if (isString(pattern)) {\n    return requireExactStringMatch ? value === pattern : value.includes(pattern);\n  }\n\n  return false;\n}\n\n/**\n * Test the given string against an array of strings and regexes. By default, string matching is done on a\n * substring-inclusion basis rather than a strict equality basis\n *\n * @param testString The string to test\n * @param patterns The patterns against which to test the string\n * @param requireExactStringMatch If true, `testString` must match one of the given string patterns exactly in order to\n * count. If false, `testString` will match a string pattern if it contains that pattern.\n * @returns\n */\nexport function stringMatchesSomePattern(\n  testString: string,\n  patterns: Array<string | RegExp> = [],\n  requireExactStringMatch: boolean = false,\n): boolean {\n  return patterns.some(pattern => isMatchingPattern(testString, pattern, requireExactStringMatch));\n}\n","import type { Client, DynamicSamplingContext, Scope, Span, Transaction } from '@sentry/types';\nimport { dropUndefinedKeys } from '@sentry/utils';\n\nimport { DEFAULT_ENVIRONMENT } from '../constants';\nimport { getClient, getCurrentScope } from '../exports';\nimport { getRootSpan } from '../utils/getRootSpan';\nimport { spanIsSampled, spanToJSON } from '../utils/spanUtils';\n\n/**\n * Creates a dynamic sampling context from a client.\n *\n * Dispatches the `createDsc` lifecycle hook as a side effect.\n */\nexport function getDynamicSamplingContextFromClient(\n  trace_id: string,\n  client: Client,\n  scope?: Scope,\n): DynamicSamplingContext {\n  const options = client.getOptions();\n\n  const { publicKey: public_key } = client.getDsn() || {};\n  // TODO(v8): Remove segment from User\n  // eslint-disable-next-line deprecation/deprecation\n  const { segment: user_segment } = (scope && scope.getUser()) || {};\n\n  const dsc = dropUndefinedKeys({\n    environment: options.environment || DEFAULT_ENVIRONMENT,\n    release: options.release,\n    user_segment,\n    public_key,\n    trace_id,\n  }) as DynamicSamplingContext;\n\n  client.emit && client.emit('createDsc', dsc);\n\n  return dsc;\n}\n\n/**\n * A Span with a frozen dynamic sampling context.\n */\ntype TransactionWithV7FrozenDsc = Transaction & { _frozenDynamicSamplingContext?: DynamicSamplingContext };\n\n/**\n * Creates a dynamic sampling context from a span (and client and scope)\n *\n * @param span the span from which a few values like the root span name and sample rate are extracted.\n *\n * @returns a dynamic sampling context\n */\nexport function getDynamicSamplingContextFromSpan(span: Span): Readonly<Partial<DynamicSamplingContext>> {\n  const client = getClient();\n  if (!client) {\n    return {};\n  }\n\n  // passing emit=false here to only emit later once the DSC is actually populated\n  const dsc = getDynamicSamplingContextFromClient(spanToJSON(span).trace_id || '', client, getCurrentScope());\n\n  // TODO (v8): Remove v7FrozenDsc as a Transaction will no longer have _frozenDynamicSamplingContext\n  const txn = getRootSpan(span) as TransactionWithV7FrozenDsc | undefined;\n  if (!txn) {\n    return dsc;\n  }\n\n  // TODO (v8): Remove v7FrozenDsc as a Transaction will no longer have _frozenDynamicSamplingContext\n  // For now we need to avoid breaking users who directly created a txn with a DSC, where this field is still set.\n  // @see Transaction class constructor\n  const v7FrozenDsc = txn && txn._frozenDynamicSamplingContext;\n  if (v7FrozenDsc) {\n    return v7FrozenDsc;\n  }\n\n  // TODO (v8): Replace txn.metadata with txn.attributes[]\n  // We can't do this yet because attributes aren't always set yet.\n  // eslint-disable-next-line deprecation/deprecation\n  const { sampleRate: maybeSampleRate, source } = txn.metadata;\n  if (maybeSampleRate != null) {\n    dsc.sample_rate = `${maybeSampleRate}`;\n  }\n\n  // We don't want to have a transaction name in the DSC if the source is \"url\" because URLs might contain PII\n  const jsonSpan = spanToJSON(txn);\n\n  // after JSON conversion, txn.name becomes jsonSpan.description\n  if (source && source !== 'url') {\n    dsc.transaction = jsonSpan.description;\n  }\n\n  dsc.sampled = String(spanIsSampled(txn));\n\n  client.emit && client.emit('createDsc', dsc);\n\n  return dsc;\n}\n","import type { Span, SpanJSON, SpanTimeInput, TraceContext } from '@sentry/types';\nimport { dropUndefinedKeys, generateSentryTraceHeader, timestampInSeconds } from '@sentry/utils';\nimport type { Span as SpanClass } from '../tracing/span';\n\n// These are aligned with OpenTelemetry trace flags\nexport const TRACE_FLAG_NONE = 0x0;\nexport const TRACE_FLAG_SAMPLED = 0x1;\n\n/**\n * Convert a span to a trace context, which can be sent as the `trace` context in an event.\n */\nexport function spanToTraceContext(span: Span): TraceContext {\n  const { spanId: span_id, traceId: trace_id } = span.spanContext();\n  const { data, op, parent_span_id, status, tags, origin } = spanToJSON(span);\n\n  return dropUndefinedKeys({\n    data,\n    op,\n    parent_span_id,\n    span_id,\n    status,\n    tags,\n    trace_id,\n    origin,\n  });\n}\n\n/**\n * Convert a Span to a Sentry trace header.\n */\nexport function spanToTraceHeader(span: Span): string {\n  const { traceId, spanId } = span.spanContext();\n  const sampled = spanIsSampled(span);\n  return generateSentryTraceHeader(traceId, spanId, sampled);\n}\n\n/**\n * Convert a span time input intp a timestamp in seconds.\n */\nexport function spanTimeInputToSeconds(input: SpanTimeInput | undefined): number {\n  if (typeof input === 'number') {\n    return ensureTimestampInSeconds(input);\n  }\n\n  if (Array.isArray(input)) {\n    // See {@link HrTime} for the array-based time format\n    return input[0] + input[1] / 1e9;\n  }\n\n  if (input instanceof Date) {\n    return ensureTimestampInSeconds(input.getTime());\n  }\n\n  return timestampInSeconds();\n}\n\n/**\n * Converts a timestamp to second, if it was in milliseconds, or keeps it as second.\n */\nfunction ensureTimestampInSeconds(timestamp: number): number {\n  const isMs = timestamp > 9999999999;\n  return isMs ? timestamp / 1000 : timestamp;\n}\n\n/**\n * Convert a span to a JSON representation.\n * Note that all fields returned here are optional and need to be guarded against.\n *\n * Note: Because of this, we currently have a circular type dependency (which we opted out of in package.json).\n * This is not avoidable as we need `spanToJSON` in `spanUtils.ts`, which in turn is needed by `span.ts` for backwards compatibility.\n * And `spanToJSON` needs the Span class from `span.ts` to check here.\n * TODO v8: When we remove the deprecated stuff from `span.ts`, we can remove the circular dependency again.\n */\nexport function spanToJSON(span: Span): Partial<SpanJSON> {\n  if (spanIsSpanClass(span)) {\n    return span.getSpanJSON();\n  }\n\n  // Fallback: We also check for `.toJSON()` here...\n  // eslint-disable-next-line deprecation/deprecation\n  if (typeof span.toJSON === 'function') {\n    // eslint-disable-next-line deprecation/deprecation\n    return span.toJSON();\n  }\n\n  return {};\n}\n\n/**\n * Sadly, due to circular dependency checks we cannot actually import the Span class here and check for instanceof.\n * :( So instead we approximate this by checking if it has the `getSpanJSON` method.\n */\nfunction spanIsSpanClass(span: Span): span is SpanClass {\n  return typeof (span as SpanClass).getSpanJSON === 'function';\n}\n\n/**\n * Returns true if a span is sampled.\n * In most cases, you should just use `span.isRecording()` instead.\n * However, this has a slightly different semantic, as it also returns false if the span is finished.\n * So in the case where this distinction is important, use this method.\n */\nexport function spanIsSampled(span: Span): boolean {\n  // We align our trace flags with the ones OpenTelemetry use\n  // So we also check for sampled the same way they do.\n  const { traceFlags } = span.spanContext();\n  // eslint-disable-next-line no-bitwise\n  return Boolean(traceFlags & TRACE_FLAG_SAMPLED);\n}\n","import { convertIntegrationFnToClass, defineIntegration } from '@sentry/core';\nimport type { Integration, IntegrationClass, IntegrationFn, WrappedFunction } from '@sentry/types';\nimport { fill, getFunctionName, getOriginalFunction } from '@sentry/utils';\n\nimport { WINDOW, wrap } from '../helpers';\n\nconst DEFAULT_EVENT_TARGET = [\n  'EventTarget',\n  'Window',\n  'Node',\n  'ApplicationCache',\n  'AudioTrackList',\n  'BroadcastChannel',\n  'ChannelMergerNode',\n  'CryptoOperation',\n  'EventSource',\n  'FileReader',\n  'HTMLUnknownElement',\n  'IDBDatabase',\n  'IDBRequest',\n  'IDBTransaction',\n  'KeyOperation',\n  'MediaController',\n  'MessagePort',\n  'ModalWindow',\n  'Notification',\n  'SVGElementInstance',\n  'Screen',\n  'SharedWorker',\n  'TextTrack',\n  'TextTrackCue',\n  'TextTrackList',\n  'WebSocket',\n  'WebSocketWorker',\n  'Worker',\n  'XMLHttpRequest',\n  'XMLHttpRequestEventTarget',\n  'XMLHttpRequestUpload',\n];\n\nconst INTEGRATION_NAME = 'TryCatch';\n\ntype XMLHttpRequestProp = 'onload' | 'onerror' | 'onprogress' | 'onreadystatechange';\n\ninterface TryCatchOptions {\n  setTimeout: boolean;\n  setInterval: boolean;\n  requestAnimationFrame: boolean;\n  XMLHttpRequest: boolean;\n  eventTarget: boolean | string[];\n}\n\nconst _browserApiErrorsIntegration = ((options: Partial<TryCatchOptions> = {}) => {\n  const _options = {\n    XMLHttpRequest: true,\n    eventTarget: true,\n    requestAnimationFrame: true,\n    setInterval: true,\n    setTimeout: true,\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    // TODO: This currently only works for the first client this is setup\n    // We may want to adjust this to check for client etc.\n    setupOnce() {\n      if (_options.setTimeout) {\n        fill(WINDOW, 'setTimeout', _wrapTimeFunction);\n      }\n\n      if (_options.setInterval) {\n        fill(WINDOW, 'setInterval', _wrapTimeFunction);\n      }\n\n      if (_options.requestAnimationFrame) {\n        fill(WINDOW, 'requestAnimationFrame', _wrapRAF);\n      }\n\n      if (_options.XMLHttpRequest && 'XMLHttpRequest' in WINDOW) {\n        fill(XMLHttpRequest.prototype, 'send', _wrapXHR);\n      }\n\n      const eventTargetOption = _options.eventTarget;\n      if (eventTargetOption) {\n        const eventTarget = Array.isArray(eventTargetOption) ? eventTargetOption : DEFAULT_EVENT_TARGET;\n        eventTarget.forEach(_wrapEventTarget);\n      }\n    },\n  };\n}) satisfies IntegrationFn;\n\nexport const browserApiErrorsIntegration = defineIntegration(_browserApiErrorsIntegration);\n\n/**\n * Wrap timer functions and event targets to catch errors and provide better meta data.\n * @deprecated Use `browserApiErrorsIntegration()` instead.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport const TryCatch = convertIntegrationFnToClass(\n  INTEGRATION_NAME,\n  browserApiErrorsIntegration,\n) as IntegrationClass<Integration> & {\n  new (options?: {\n    setTimeout: boolean;\n    setInterval: boolean;\n    requestAnimationFrame: boolean;\n    XMLHttpRequest: boolean;\n    eventTarget: boolean | string[];\n  }): Integration;\n};\n\nfunction _wrapTimeFunction(original: () => void): () => number {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function (this: any, ...args: any[]): number {\n    const originalCallback = args[0];\n    args[0] = wrap(originalCallback, {\n      mechanism: {\n        data: { function: getFunctionName(original) },\n        handled: false,\n        type: 'instrument',\n      },\n    });\n    return original.apply(this, args);\n  };\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _wrapRAF(original: any): (callback: () => void) => any {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function (this: any, callback: () => void): () => void {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return original.apply(this, [\n      wrap(callback, {\n        mechanism: {\n          data: {\n            function: 'requestAnimationFrame',\n            handler: getFunctionName(original),\n          },\n          handled: false,\n          type: 'instrument',\n        },\n      }),\n    ]);\n  };\n}\n\nfunction _wrapXHR(originalSend: () => void): () => void {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return function (this: XMLHttpRequest, ...args: any[]): void {\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const xhr = this;\n    const xmlHttpRequestProps: XMLHttpRequestProp[] = ['onload', 'onerror', 'onprogress', 'onreadystatechange'];\n\n    xmlHttpRequestProps.forEach(prop => {\n      if (prop in xhr && typeof xhr[prop] === 'function') {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        fill(xhr, prop, function (original: WrappedFunction): () => any {\n          const wrapOptions = {\n            mechanism: {\n              data: {\n                function: prop,\n                handler: getFunctionName(original),\n              },\n              handled: false,\n              type: 'instrument',\n            },\n          };\n\n          // If Instrument integration has been called before TryCatch, get the name of original function\n          const originalFunction = getOriginalFunction(original);\n          if (originalFunction) {\n            wrapOptions.mechanism.data.handler = getFunctionName(originalFunction);\n          }\n\n          // Otherwise wrap directly\n          return wrap(original, wrapOptions);\n        });\n      }\n    });\n\n    return originalSend.apply(this, args);\n  };\n}\n\nfunction _wrapEventTarget(target: string): void {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const globalObject = WINDOW as { [key: string]: any };\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  const proto = globalObject[target] && globalObject[target].prototype;\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins\n  if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n    return;\n  }\n\n  fill(proto, 'addEventListener', function (original: VoidFunction,): (\n    eventName: string,\n    fn: EventListenerObject,\n    options?: boolean | AddEventListenerOptions,\n  ) => void {\n    return function (\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      this: any,\n      eventName: string,\n      fn: EventListenerObject,\n      options?: boolean | AddEventListenerOptions,\n    ): (eventName: string, fn: EventListenerObject, capture?: boolean, secure?: boolean) => void {\n      try {\n        if (typeof fn.handleEvent === 'function') {\n          // ESlint disable explanation:\n          //  First, it is generally safe to call `wrap` with an unbound function. Furthermore, using `.bind()` would\n          //  introduce a bug here, because bind returns a new function that doesn't have our\n          //  flags(like __sentry_original__) attached. `wrap` checks for those flags to avoid unnecessary wrapping.\n          //  Without those flags, every call to addEventListener wraps the function again, causing a memory leak.\n          // eslint-disable-next-line @typescript-eslint/unbound-method\n          fn.handleEvent = wrap(fn.handleEvent, {\n            mechanism: {\n              data: {\n                function: 'handleEvent',\n                handler: getFunctionName(fn),\n                target,\n              },\n              handled: false,\n              type: 'instrument',\n            },\n          });\n        }\n      } catch (err) {\n        // can sometimes get 'Permission denied to access property \"handle Event'\n      }\n\n      return original.apply(this, [\n        eventName,\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        wrap(fn as any as WrappedFunction, {\n          mechanism: {\n            data: {\n              function: 'addEventListener',\n              handler: getFunctionName(fn),\n              target,\n            },\n            handled: false,\n            type: 'instrument',\n          },\n        }),\n        options,\n      ]);\n    };\n  });\n\n  fill(\n    proto,\n    'removeEventListener',\n    function (\n      originalRemoveEventListener: () => void,\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ): (this: any, eventName: string, fn: EventListenerObject, options?: boolean | EventListenerOptions) => () => void {\n      return function (\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        this: any,\n        eventName: string,\n        fn: EventListenerObject,\n        options?: boolean | EventListenerOptions,\n      ): () => void {\n        /**\n         * There are 2 possible scenarios here:\n         *\n         * 1. Someone passes a callback, which was attached prior to Sentry initialization, or by using unmodified\n         * method, eg. `document.addEventListener.call(el, name, handler). In this case, we treat this function\n         * as a pass-through, and call original `removeEventListener` with it.\n         *\n         * 2. Someone passes a callback, which was attached after Sentry was initialized, which means that it was using\n         * our wrapped version of `addEventListener`, which internally calls `wrap` helper.\n         * This helper \"wraps\" whole callback inside a try/catch statement, and attached appropriate metadata to it,\n         * in order for us to make a distinction between wrapped/non-wrapped functions possible.\n         * If a function was wrapped, it has additional property of `__sentry_wrapped__`, holding the handler.\n         *\n         * When someone adds a handler prior to initialization, and then do it again, but after,\n         * then we have to detach both of them. Otherwise, if we'd detach only wrapped one, it'd be impossible\n         * to get rid of the initial handler and it'd stick there forever.\n         */\n        const wrappedEventHandler = fn as unknown as WrappedFunction;\n        try {\n          const originalEventHandler = wrappedEventHandler && wrappedEventHandler.__sentry_wrapped__;\n          if (originalEventHandler) {\n            originalRemoveEventListener.call(this, eventName, originalEventHandler, options);\n          }\n        } catch (e) {\n          // ignore, accessing __sentry_wrapped__ will throw in some Selenium environments\n        }\n        return originalRemoveEventListener.call(this, eventName, wrappedEventHandler, options);\n      };\n    },\n  );\n}\n","import type { DynamicSamplingContext } from '@sentry/types';\n\nimport { DEBUG_BUILD } from './debug-build';\nimport { isString } from './is';\nimport { logger } from './logger';\n\nexport const BAGGAGE_HEADER_NAME = 'baggage';\n\nexport const SENTRY_BAGGAGE_KEY_PREFIX = 'sentry-';\n\nexport const SENTRY_BAGGAGE_KEY_PREFIX_REGEX = /^sentry-/;\n\n/**\n * Max length of a serialized baggage string\n *\n * https://www.w3.org/TR/baggage/#limits\n */\nexport const MAX_BAGGAGE_STRING_LENGTH = 8192;\n\n/**\n * Takes a baggage header and turns it into Dynamic Sampling Context, by extracting all the \"sentry-\" prefixed values\n * from it.\n *\n * @param baggageHeader A very bread definition of a baggage header as it might appear in various frameworks.\n * @returns The Dynamic Sampling Context that was found on `baggageHeader`, if there was any, `undefined` otherwise.\n */\nexport function baggageHeaderToDynamicSamplingContext(\n  // Very liberal definition of what any incoming header might look like\n  baggageHeader: string | string[] | number | null | undefined | boolean,\n): Partial<DynamicSamplingContext> | undefined {\n  if (!isString(baggageHeader) && !Array.isArray(baggageHeader)) {\n    return undefined;\n  }\n\n  // Intermediary object to store baggage key value pairs of incoming baggage headers on.\n  // It is later used to read Sentry-DSC-values from.\n  let baggageObject: Readonly<Record<string, string>> = {};\n\n  if (Array.isArray(baggageHeader)) {\n    // Combine all baggage headers into one object containing the baggage values so we can later read the Sentry-DSC-values from it\n    baggageObject = baggageHeader.reduce<Record<string, string>>((acc, curr) => {\n      const currBaggageObject = baggageHeaderToObject(curr);\n      for (const key of Object.keys(currBaggageObject)) {\n        acc[key] = currBaggageObject[key];\n      }\n      return acc;\n    }, {});\n  } else {\n    // Return undefined if baggage header is an empty string (technically an empty baggage header is not spec conform but\n    // this is how we choose to handle it)\n    if (!baggageHeader) {\n      return undefined;\n    }\n\n    baggageObject = baggageHeaderToObject(baggageHeader);\n  }\n\n  // Read all \"sentry-\" prefixed values out of the baggage object and put it onto a dynamic sampling context object.\n  const dynamicSamplingContext = Object.entries(baggageObject).reduce<Record<string, string>>((acc, [key, value]) => {\n    if (key.match(SENTRY_BAGGAGE_KEY_PREFIX_REGEX)) {\n      const nonPrefixedKey = key.slice(SENTRY_BAGGAGE_KEY_PREFIX.length);\n      acc[nonPrefixedKey] = value;\n    }\n    return acc;\n  }, {});\n\n  // Only return a dynamic sampling context object if there are keys in it.\n  // A keyless object means there were no sentry values on the header, which means that there is no DSC.\n  if (Object.keys(dynamicSamplingContext).length > 0) {\n    return dynamicSamplingContext as Partial<DynamicSamplingContext>;\n  } else {\n    return undefined;\n  }\n}\n\n/**\n * Turns a Dynamic Sampling Object into a baggage header by prefixing all the keys on the object with \"sentry-\".\n *\n * @param dynamicSamplingContext The Dynamic Sampling Context to turn into a header. For convenience and compatibility\n * with the `getDynamicSamplingContext` method on the Transaction class ,this argument can also be `undefined`. If it is\n * `undefined` the function will return `undefined`.\n * @returns a baggage header, created from `dynamicSamplingContext`, or `undefined` either if `dynamicSamplingContext`\n * was `undefined`, or if `dynamicSamplingContext` didn't contain any values.\n */\nexport function dynamicSamplingContextToSentryBaggageHeader(\n  // this also takes undefined for convenience and bundle size in other places\n  dynamicSamplingContext?: Partial<DynamicSamplingContext>,\n): string | undefined {\n  if (!dynamicSamplingContext) {\n    return undefined;\n  }\n\n  // Prefix all DSC keys with \"sentry-\" and put them into a new object\n  const sentryPrefixedDSC = Object.entries(dynamicSamplingContext).reduce<Record<string, string>>(\n    (acc, [dscKey, dscValue]) => {\n      if (dscValue) {\n        acc[`${SENTRY_BAGGAGE_KEY_PREFIX}${dscKey}`] = dscValue;\n      }\n      return acc;\n    },\n    {},\n  );\n\n  return objectToBaggageHeader(sentryPrefixedDSC);\n}\n\n/**\n * Will parse a baggage header, which is a simple key-value map, into a flat object.\n *\n * @param baggageHeader The baggage header to parse.\n * @returns a flat object containing all the key-value pairs from `baggageHeader`.\n */\nfunction baggageHeaderToObject(baggageHeader: string): Record<string, string> {\n  return baggageHeader\n    .split(',')\n    .map(baggageEntry => baggageEntry.split('=').map(keyOrValue => decodeURIComponent(keyOrValue.trim())))\n    .reduce<Record<string, string>>((acc, [key, value]) => {\n      acc[key] = value;\n      return acc;\n    }, {});\n}\n\n/**\n * Turns a flat object (key-value pairs) into a baggage header, which is also just key-value pairs.\n *\n * @param object The object to turn into a baggage header.\n * @returns a baggage header string, or `undefined` if the object didn't have any values, since an empty baggage header\n * is not spec compliant.\n */\nfunction objectToBaggageHeader(object: Record<string, string>): string | undefined {\n  if (Object.keys(object).length === 0) {\n    // An empty baggage header is not spec compliant: We return undefined.\n    return undefined;\n  }\n\n  return Object.entries(object).reduce((baggageHeader, [objectKey, objectValue], currentIndex) => {\n    const baggageEntry = `${encodeURIComponent(objectKey)}=${encodeURIComponent(objectValue)}`;\n    const newBaggageHeader = currentIndex === 0 ? baggageEntry : `${baggageHeader},${baggageEntry}`;\n    if (newBaggageHeader.length > MAX_BAGGAGE_STRING_LENGTH) {\n      DEBUG_BUILD &&\n        logger.warn(\n          `Not adding key: ${objectKey} with val: ${objectValue} to baggage header due to exceeding baggage size limits.`,\n        );\n      return baggageHeader;\n    } else {\n      return newBaggageHeader;\n    }\n  }, '');\n}\n","/**\n * NOTE: In order to avoid circular dependencies, if you add a function to this module and it needs to print something,\n * you must either a) use `console.log` rather than the logger, or b) put your function elsewhere.\n */\n\nimport { isBrowserBundle } from './env';\n\n/**\n * Checks whether we're in the Node.js or Browser environment\n *\n * @returns Answer to given question\n */\nexport function isNodeEnv(): boolean {\n  // explicitly check for browser bundles as those can be optimized statically\n  // by terser/rollup.\n  return (\n    !isBrowserBundle() &&\n    Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]'\n  );\n}\n\n/**\n * Requires a module which is protected against bundler minification.\n *\n * @param request The module path to resolve\n */\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any\nexport function dynamicRequire(mod: any, request: string): any {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return mod.require(request);\n}\n\n/**\n * Helper for dynamically loading module that should work with linked dependencies.\n * The problem is that we _should_ be using `require(require.resolve(moduleName, { paths: [cwd()] }))`\n * However it's _not possible_ to do that with Webpack, as it has to know all the dependencies during\n * build time. `require.resolve` is also not available in any other way, so we cannot create,\n * a fake helper like we do with `dynamicRequire`.\n *\n * We always prefer to use local package, thus the value is not returned early from each `try/catch` block.\n * That is to mimic the behavior of `require.resolve` exactly.\n *\n * @param moduleName module name to require\n * @returns possibly required module\n */\nexport function loadModule<T>(moduleName: string): T | undefined {\n  let mod: T | undefined;\n\n  try {\n    mod = dynamicRequire(module, moduleName);\n  } catch (e) {\n    // no-empty\n  }\n\n  try {\n    const { cwd } = dynamicRequire(module, 'process');\n    mod = dynamicRequire(module, `${cwd()}/node_modules/${moduleName}`) as T;\n  } catch (e) {\n    // no-empty\n  }\n\n  return mod;\n}\n","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\nimport { captureEvent, convertIntegrationFnToClass, defineIntegration, getClient } from '@sentry/core';\nimport type {\n  Client,\n  Event,\n  Integration,\n  IntegrationClass,\n  IntegrationFn,\n  Primitive,\n  StackParser,\n} from '@sentry/types';\nimport {\n  addGlobalErrorInstrumentationHandler,\n  addGlobalUnhandledRejectionInstrumentationHandler,\n  getLocationHref,\n  isErrorEvent,\n  isPrimitive,\n  isString,\n  logger,\n} from '@sentry/utils';\n\nimport type { BrowserClient } from '../client';\nimport { DEBUG_BUILD } from '../debug-build';\nimport { eventFromUnknownInput } from '../eventbuilder';\nimport { shouldIgnoreOnError } from '../helpers';\n\ntype GlobalHandlersIntegrationsOptionKeys = 'onerror' | 'onunhandledrejection';\n\ntype GlobalHandlersIntegrations = Record<GlobalHandlersIntegrationsOptionKeys, boolean>;\n\nconst INTEGRATION_NAME = 'GlobalHandlers';\n\nconst _globalHandlersIntegration = ((options: Partial<GlobalHandlersIntegrations> = {}) => {\n  const _options = {\n    onerror: true,\n    onunhandledrejection: true,\n    ...options,\n  };\n\n  return {\n    name: INTEGRATION_NAME,\n    setupOnce() {\n      Error.stackTraceLimit = 50;\n    },\n    setup(client) {\n      if (_options.onerror) {\n        _installGlobalOnErrorHandler(client);\n        globalHandlerLog('onerror');\n      }\n      if (_options.onunhandledrejection) {\n        _installGlobalOnUnhandledRejectionHandler(client);\n        globalHandlerLog('onunhandledrejection');\n      }\n    },\n  };\n}) satisfies IntegrationFn;\n\nexport const globalHandlersIntegration = defineIntegration(_globalHandlersIntegration);\n\n/**\n * Global handlers.\n * @deprecated Use `globalHandlersIntegration()` instead.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport const GlobalHandlers = convertIntegrationFnToClass(\n  INTEGRATION_NAME,\n  globalHandlersIntegration,\n) as IntegrationClass<Integration & { setup: (client: Client) => void }> & {\n  new (options?: Partial<GlobalHandlersIntegrations>): Integration;\n};\n\nfunction _installGlobalOnErrorHandler(client: Client): void {\n  addGlobalErrorInstrumentationHandler(data => {\n    const { stackParser, attachStacktrace } = getOptions();\n\n    if (getClient() !== client || shouldIgnoreOnError()) {\n      return;\n    }\n\n    const { msg, url, line, column, error } = data;\n\n    const event =\n      error === undefined && isString(msg)\n        ? _eventFromIncompleteOnError(msg, url, line, column)\n        : _enhanceEventWithInitialFrame(\n            eventFromUnknownInput(stackParser, error || msg, undefined, attachStacktrace, false),\n            url,\n            line,\n            column,\n          );\n\n    event.level = 'error';\n\n    captureEvent(event, {\n      originalException: error,\n      mechanism: {\n        handled: false,\n        type: 'onerror',\n      },\n    });\n  });\n}\n\nfunction _installGlobalOnUnhandledRejectionHandler(client: Client): void {\n  addGlobalUnhandledRejectionInstrumentationHandler(e => {\n    const { stackParser, attachStacktrace } = getOptions();\n\n    if (getClient() !== client || shouldIgnoreOnError()) {\n      return;\n    }\n\n    const error = _getUnhandledRejectionError(e as unknown);\n\n    const event = isPrimitive(error)\n      ? _eventFromRejectionWithPrimitive(error)\n      : eventFromUnknownInput(stackParser, error, undefined, attachStacktrace, true);\n\n    event.level = 'error';\n\n    captureEvent(event, {\n      originalException: error,\n      mechanism: {\n        handled: false,\n        type: 'onunhandledrejection',\n      },\n    });\n  });\n}\n\nfunction _getUnhandledRejectionError(error: unknown): unknown {\n  if (isPrimitive(error)) {\n    return error;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const e = error as any;\n\n  // dig the object of the rejection out of known event types\n  try {\n    // PromiseRejectionEvents store the object of the rejection under 'reason'\n    // see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent\n    if ('reason' in e) {\n      return e.reason;\n    }\n\n    // something, somewhere, (likely a browser extension) effectively casts PromiseRejectionEvents\n    // to CustomEvents, moving the `promise` and `reason` attributes of the PRE into\n    // the CustomEvent's `detail` attribute, since they're not part of CustomEvent's spec\n    // see https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent and\n    // https://github.com/getsentry/sentry-javascript/issues/2380\n    else if ('detail' in e && 'reason' in e.detail) {\n      return e.detail.reason;\n    }\n  } catch {} // eslint-disable-line no-empty\n\n  return error;\n}\n\n/**\n * Create an event from a promise rejection where the `reason` is a primitive.\n *\n * @param reason: The `reason` property of the promise rejection\n * @returns An Event object with an appropriate `exception` value\n */\nfunction _eventFromRejectionWithPrimitive(reason: Primitive): Event {\n  return {\n    exception: {\n      values: [\n        {\n          type: 'UnhandledRejection',\n          // String() is needed because the Primitive type includes symbols (which can't be automatically stringified)\n          value: `Non-Error promise rejection captured with value: ${String(reason)}`,\n        },\n      ],\n    },\n  };\n}\n\n/**\n * This function creates a stack from an old, error-less onerror handler.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _eventFromIncompleteOnError(msg: any, url: any, line: any, column: any): Event {\n  const ERROR_TYPES_RE =\n    /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;\n\n  // If 'message' is ErrorEvent, get real message from inside\n  let message = isErrorEvent(msg) ? msg.message : msg;\n  let name = 'Error';\n\n  const groups = message.match(ERROR_TYPES_RE);\n  if (groups) {\n    name = groups[1];\n    message = groups[2];\n  }\n\n  const event = {\n    exception: {\n      values: [\n        {\n          type: name,\n          value: message,\n        },\n      ],\n    },\n  };\n\n  return _enhanceEventWithInitialFrame(event, url, line, column);\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction _enhanceEventWithInitialFrame(event: Event, url: any, line: any, column: any): Event {\n  // event.exception\n  const e = (event.exception = event.exception || {});\n  // event.exception.values\n  const ev = (e.values = e.values || []);\n  // event.exception.values[0]\n  const ev0 = (ev[0] = ev[0] || {});\n  // event.exception.values[0].stacktrace\n  const ev0s = (ev0.stacktrace = ev0.stacktrace || {});\n  // event.exception.values[0].stacktrace.frames\n  const ev0sf = (ev0s.frames = ev0s.frames || []);\n\n  const colno = isNaN(parseInt(column, 10)) ? undefined : column;\n  const lineno = isNaN(parseInt(line, 10)) ? undefined : line;\n  const filename = isString(url) && url.length > 0 ? url : getLocationHref();\n\n  // event.exception.values[0].stacktrace.frames\n  if (ev0sf.length === 0) {\n    ev0sf.push({\n      colno,\n      filename,\n      function: '?',\n      in_app: true,\n      lineno,\n    });\n  }\n\n  return event;\n}\n\nfunction globalHandlerLog(type: string): void {\n  DEBUG_BUILD && logger.log(`Global Handler attached: ${type}`);\n}\n\nfunction getOptions(): { stackParser: StackParser; attachStacktrace?: boolean } {\n  const client = getClient<BrowserClient>();\n  const options = (client && client.getOptions()) || {\n    stackParser: () => [],\n    attachStacktrace: false,\n  };\n  return options;\n}\n","import { isThenable } from '@sentry/utils';\n\n/**\n * Wrap a callback function with error handling.\n * If an error is thrown, it will be passed to the `onError` callback and re-thrown.\n *\n * If the return value of the function is a promise, it will be handled with `maybeHandlePromiseRejection`.\n *\n * If an `onFinally` callback is provided, this will be called when the callback has finished\n * - so if it returns a promise, once the promise resolved/rejected,\n * else once the callback has finished executing.\n * The `onFinally` callback will _always_ be called, no matter if an error was thrown or not.\n */\nexport function handleCallbackErrors<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  Fn extends () => any,\n>(\n  fn: Fn,\n  onError: (error: unknown) => void,\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  onFinally: () => void = () => {},\n): ReturnType<Fn> {\n  let maybePromiseResult: ReturnType<Fn>;\n  try {\n    maybePromiseResult = fn();\n  } catch (e) {\n    onError(e);\n    onFinally();\n    throw e;\n  }\n\n  return maybeHandlePromiseRejection(maybePromiseResult, onError, onFinally);\n}\n\n/**\n * Maybe handle a promise rejection.\n * This expects to be given a value that _may_ be a promise, or any other value.\n * If it is a promise, and it rejects, it will call the `onError` callback.\n * Other than this, it will generally return the given value as-is.\n */\nfunction maybeHandlePromiseRejection<MaybePromise>(\n  value: MaybePromise,\n  onError: (error: unknown) => void,\n  onFinally: () => void,\n): MaybePromise {\n  if (isThenable(value)) {\n    // @ts-expect-error - the isThenable check returns the \"wrong\" type here\n    return value.then(\n      res => {\n        onFinally();\n        return res;\n      },\n      e => {\n        onError(e);\n        onFinally();\n        throw e;\n      },\n    );\n  }\n\n  onFinally();\n  return value;\n}\n","import type { Scope, Span, SpanTimeInput, StartSpanOptions, TransactionContext } from '@sentry/types';\n\nimport { addNonEnumerableProperty, dropUndefinedKeys, logger, tracingContextFromHeaders } from '@sentry/utils';\nimport { getDynamicSamplingContextFromSpan } from '.';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport { getCurrentScope, withScope } from '../exports';\nimport type { Hub } from '../hub';\nimport { runWithAsyncContext } from '../hub';\nimport { getIsolationScope } from '../hub';\nimport { getCurrentHub } from '../hub';\nimport type { Scope as ScopeClass } from '../scope';\nimport { handleCallbackErrors } from '../utils/handleCallbackErrors';\nimport { hasTracingEnabled } from '../utils/hasTracingEnabled';\nimport { spanIsSampled, spanTimeInputToSeconds, spanToJSON } from '../utils/spanUtils';\n\n/**\n * Wraps a function with a transaction/span and finishes the span after the function is done.\n *\n * Note that if you have not enabled tracing extensions via `addTracingExtensions`\n * or you didn't set `tracesSampleRate`, this function will not generate spans\n * and the `span` returned from the callback will be undefined.\n *\n * This function is meant to be used internally and may break at any time. Use at your own risk.\n *\n * @internal\n * @private\n *\n * @deprecated Use `startSpan` instead.\n */\nexport function trace<T>(\n  context: TransactionContext,\n  callback: (span?: Span) => T,\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  onError: (error: unknown, span?: Span) => void = () => {},\n  // eslint-disable-next-line @typescript-eslint/no-empty-function\n  afterFinish: () => void = () => {},\n): T {\n  // eslint-disable-next-line deprecation/deprecation\n  const hub = getCurrentHub();\n  const scope = getCurrentScope();\n  // eslint-disable-next-line deprecation/deprecation\n  const parentSpan = scope.getSpan();\n\n  const spanContext = normalizeContext(context);\n  const activeSpan = createChildSpanOrTransaction(hub, {\n    parentSpan,\n    spanContext,\n    forceTransaction: false,\n    scope,\n  });\n\n  // eslint-disable-next-line deprecation/deprecation\n  scope.setSpan(activeSpan);\n\n  return handleCallbackErrors(\n    () => callback(activeSpan),\n    error => {\n      activeSpan && activeSpan.setStatus('internal_error');\n      onError(error, activeSpan);\n    },\n    () => {\n      activeSpan && activeSpan.end();\n      // eslint-disable-next-line deprecation/deprecation\n      scope.setSpan(parentSpan);\n      afterFinish();\n    },\n  );\n}\n\n/**\n * Wraps a function with a transaction/span and finishes the span after the function is done.\n * The created span is the active span and will be used as parent by other spans created inside the function\n * and can be accessed via `Sentry.getSpan()`, as long as the function is executed while the scope is active.\n *\n * If you want to create a span that is not set as active, use {@link startInactiveSpan}.\n *\n * Note that if you have not enabled tracing extensions via `addTracingExtensions`\n * or you didn't set `tracesSampleRate`, this function will not generate spans\n * and the `span` returned from the callback will be undefined.\n */\nexport function startSpan<T>(context: StartSpanOptions, callback: (span: Span | undefined) => T): T {\n  const spanContext = normalizeContext(context);\n\n  return runWithAsyncContext(() => {\n    return withScope(context.scope, scope => {\n      // eslint-disable-next-line deprecation/deprecation\n      const hub = getCurrentHub();\n      // eslint-disable-next-line deprecation/deprecation\n      const parentSpan = scope.getSpan();\n\n      const shouldSkipSpan = context.onlyIfParent && !parentSpan;\n      const activeSpan = shouldSkipSpan\n        ? undefined\n        : createChildSpanOrTransaction(hub, {\n            parentSpan,\n            spanContext,\n            forceTransaction: context.forceTransaction,\n            scope,\n          });\n\n      return handleCallbackErrors(\n        () => callback(activeSpan),\n        () => {\n          // Only update the span status if it hasn't been changed yet\n          if (activeSpan) {\n            const { status } = spanToJSON(activeSpan);\n            if (!status || status === 'ok') {\n              activeSpan.setStatus('internal_error');\n            }\n          }\n        },\n        () => activeSpan && activeSpan.end(),\n      );\n    });\n  });\n}\n\n/**\n * @deprecated Use {@link startSpan} instead.\n */\nexport const startActiveSpan = startSpan;\n\n/**\n * Similar to `Sentry.startSpan`. Wraps a function with a transaction/span, but does not finish the span\n * after the function is done automatically. You'll have to call `span.end()` manually.\n *\n * The created span is the active span and will be used as parent by other spans created inside the function\n * and can be accessed via `Sentry.getActiveSpan()`, as long as the function is executed while the scope is active.\n *\n * Note that if you have not enabled tracing extensions via `addTracingExtensions`\n * or you didn't set `tracesSampleRate`, this function will not generate spans\n * and the `span` returned from the callback will be undefined.\n */\nexport function startSpanManual<T>(\n  context: StartSpanOptions,\n  callback: (span: Span | undefined, finish: () => void) => T,\n): T {\n  const spanContext = normalizeContext(context);\n\n  return runWithAsyncContext(() => {\n    return withScope(context.scope, scope => {\n      // eslint-disable-next-line deprecation/deprecation\n      const hub = getCurrentHub();\n      // eslint-disable-next-line deprecation/deprecation\n      const parentSpan = scope.getSpan();\n\n      const shouldSkipSpan = context.onlyIfParent && !parentSpan;\n      const activeSpan = shouldSkipSpan\n        ? undefined\n        : createChildSpanOrTransaction(hub, {\n            parentSpan,\n            spanContext,\n            forceTransaction: context.forceTransaction,\n            scope,\n          });\n\n      function finishAndSetSpan(): void {\n        activeSpan && activeSpan.end();\n      }\n\n      return handleCallbackErrors(\n        () => callback(activeSpan, finishAndSetSpan),\n        () => {\n          // Only update the span status if it hasn't been changed yet, and the span is not yet finished\n          if (activeSpan && activeSpan.isRecording()) {\n            const { status } = spanToJSON(activeSpan);\n            if (!status || status === 'ok') {\n              activeSpan.setStatus('internal_error');\n            }\n          }\n        },\n      );\n    });\n  });\n}\n\n/**\n * Creates a span. This span is not set as active, so will not get automatic instrumentation spans\n * as children or be able to be accessed via `Sentry.getSpan()`.\n *\n * If you want to create a span that is set as active, use {@link startSpan}.\n *\n * Note that if you have not enabled tracing extensions via `addTracingExtensions`\n * or you didn't set `tracesSampleRate` or `tracesSampler`, this function will not generate spans\n * and the `span` returned from the callback will be undefined.\n */\nexport function startInactiveSpan(context: StartSpanOptions): Span | undefined {\n  if (!hasTracingEnabled()) {\n    return undefined;\n  }\n\n  const spanContext = normalizeContext(context);\n  // eslint-disable-next-line deprecation/deprecation\n  const hub = getCurrentHub();\n  const parentSpan = context.scope\n    ? // eslint-disable-next-line deprecation/deprecation\n      context.scope.getSpan()\n    : getActiveSpan();\n\n  const shouldSkipSpan = context.onlyIfParent && !parentSpan;\n\n  if (shouldSkipSpan) {\n    return undefined;\n  }\n\n  const scope = context.scope || getCurrentScope();\n\n  // Even though we don't actually want to make this span active on the current scope,\n  // we need to make it active on a temporary scope that we use for event processing\n  // as otherwise, it won't pick the correct span for the event when processing it\n  const temporaryScope = (scope as ScopeClass).clone();\n\n  return createChildSpanOrTransaction(hub, {\n    parentSpan,\n    spanContext,\n    forceTransaction: context.forceTransaction,\n    scope: temporaryScope,\n  });\n}\n\n/**\n * Returns the currently active span.\n */\nexport function getActiveSpan(): Span | undefined {\n  // eslint-disable-next-line deprecation/deprecation\n  return getCurrentScope().getSpan();\n}\n\ninterface ContinueTrace {\n  /**\n   * Continue a trace from `sentry-trace` and `baggage` values.\n   * These values can be obtained from incoming request headers,\n   * or in the browser from `<meta name=\"sentry-trace\">` and `<meta name=\"baggage\">` HTML tags.\n   *\n   * @deprecated Use the version of this function taking a callback as second parameter instead:\n   *\n   * ```\n   * Sentry.continueTrace(sentryTrace: '...', baggage: '...' }, () => {\n   *    // ...\n   * })\n   * ```\n   *\n   */\n  ({\n    sentryTrace,\n    baggage,\n  }: {\n    // eslint-disable-next-line deprecation/deprecation\n    sentryTrace: Parameters<typeof tracingContextFromHeaders>[0];\n    // eslint-disable-next-line deprecation/deprecation\n    baggage: Parameters<typeof tracingContextFromHeaders>[1];\n  }): Partial<TransactionContext>;\n\n  /**\n   * Continue a trace from `sentry-trace` and `baggage` values.\n   * These values can be obtained from incoming request headers, or in the browser from `<meta name=\"sentry-trace\">`\n   * and `<meta name=\"baggage\">` HTML tags.\n   *\n   * Spans started with `startSpan`, `startSpanManual` and `startInactiveSpan`, within the callback will automatically\n   * be attached to the incoming trace.\n   *\n   * Deprecation notice: In the next major version of the SDK the provided callback will not receive a transaction\n   * context argument.\n   */\n  <V>(\n    {\n      sentryTrace,\n      baggage,\n    }: {\n      // eslint-disable-next-line deprecation/deprecation\n      sentryTrace: Parameters<typeof tracingContextFromHeaders>[0];\n      // eslint-disable-next-line deprecation/deprecation\n      baggage: Parameters<typeof tracingContextFromHeaders>[1];\n    },\n    // TODO(v8): Remove parameter from this callback.\n    callback: (transactionContext: Partial<TransactionContext>) => V,\n  ): V;\n}\n\nexport const continueTrace: ContinueTrace = <V>(\n  {\n    sentryTrace,\n    baggage,\n  }: {\n    // eslint-disable-next-line deprecation/deprecation\n    sentryTrace: Parameters<typeof tracingContextFromHeaders>[0];\n    // eslint-disable-next-line deprecation/deprecation\n    baggage: Parameters<typeof tracingContextFromHeaders>[1];\n  },\n  callback?: (transactionContext: Partial<TransactionContext>) => V,\n): V | Partial<TransactionContext> => {\n  // TODO(v8): Change this function so it doesn't do anything besides setting the propagation context on the current scope:\n  /*\n    return withScope((scope) => {\n      const propagationContext = propagationContextFromHeaders(sentryTrace, baggage);\n      scope.setPropagationContext(propagationContext);\n      return callback();\n    })\n  */\n\n  const currentScope = getCurrentScope();\n\n  // eslint-disable-next-line deprecation/deprecation\n  const { traceparentData, dynamicSamplingContext, propagationContext } = tracingContextFromHeaders(\n    sentryTrace,\n    baggage,\n  );\n\n  currentScope.setPropagationContext(propagationContext);\n\n  if (DEBUG_BUILD && traceparentData) {\n    logger.log(`[Tracing] Continuing trace ${traceparentData.traceId}.`);\n  }\n\n  const transactionContext: Partial<TransactionContext> = {\n    ...traceparentData,\n    metadata: dropUndefinedKeys({\n      dynamicSamplingContext,\n    }),\n  };\n\n  if (!callback) {\n    return transactionContext;\n  }\n\n  return runWithAsyncContext(() => {\n    return callback(transactionContext);\n  });\n};\n\nfunction createChildSpanOrTransaction(\n  // eslint-disable-next-line deprecation/deprecation\n  hub: Hub,\n  {\n    parentSpan,\n    spanContext,\n    forceTransaction,\n    scope,\n  }: {\n    parentSpan: Span | undefined;\n    spanContext: TransactionContext;\n    forceTransaction?: boolean;\n    scope: Scope;\n  },\n): Span | undefined {\n  if (!hasTracingEnabled()) {\n    return undefined;\n  }\n\n  const isolationScope = getIsolationScope();\n\n  let span: Span | undefined;\n  if (parentSpan && !forceTransaction) {\n    // eslint-disable-next-line deprecation/deprecation\n    span = parentSpan.startChild(spanContext);\n  } else if (parentSpan) {\n    // If we forced a transaction but have a parent span, make sure to continue from the parent span, not the scope\n    const dsc = getDynamicSamplingContextFromSpan(parentSpan);\n    const { traceId, spanId: parentSpanId } = parentSpan.spanContext();\n    const sampled = spanIsSampled(parentSpan);\n\n    // eslint-disable-next-line deprecation/deprecation\n    span = hub.startTransaction({\n      traceId,\n      parentSpanId,\n      parentSampled: sampled,\n      ...spanContext,\n      metadata: {\n        dynamicSamplingContext: dsc,\n        // eslint-disable-next-line deprecation/deprecation\n        ...spanContext.metadata,\n      },\n    });\n  } else {\n    const { traceId, dsc, parentSpanId, sampled } = {\n      ...isolationScope.getPropagationContext(),\n      ...scope.getPropagationContext(),\n    };\n\n    // eslint-disable-next-line deprecation/deprecation\n    span = hub.startTransaction({\n      traceId,\n      parentSpanId,\n      parentSampled: sampled,\n      ...spanContext,\n      metadata: {\n        dynamicSamplingContext: dsc,\n        // eslint-disable-next-line deprecation/deprecation\n        ...spanContext.metadata,\n      },\n    });\n  }\n\n  // We always set this as active span on the scope\n  // In the case of this being an inactive span, we ensure to pass a detached scope in here in the first place\n  // But by having this here, we can ensure that the lookup through `getCapturedScopesOnSpan` results in the correct scope & span combo\n  // eslint-disable-next-line deprecation/deprecation\n  scope.setSpan(span);\n\n  setCapturedScopesOnSpan(span, scope, isolationScope);\n\n  return span;\n}\n\n/**\n * This converts StartSpanOptions to TransactionContext.\n * For the most part (for now) we accept the same options,\n * but some of them need to be transformed.\n *\n * Eventually the StartSpanOptions will be more aligned with OpenTelemetry.\n */\nfunction normalizeContext(context: StartSpanOptions): TransactionContext {\n  if (context.startTime) {\n    const ctx: TransactionContext & { startTime?: SpanTimeInput } = { ...context };\n    ctx.startTimestamp = spanTimeInputToSeconds(context.startTime);\n    delete ctx.startTime;\n    return ctx;\n  }\n\n  return context;\n}\n\nconst SCOPE_ON_START_SPAN_FIELD = '_sentryScope';\nconst ISOLATION_SCOPE_ON_START_SPAN_FIELD = '_sentryIsolationScope';\n\ntype SpanWithScopes = Span & {\n  [SCOPE_ON_START_SPAN_FIELD]?: Scope;\n  [ISOLATION_SCOPE_ON_START_SPAN_FIELD]?: Scope;\n};\n\nfunction setCapturedScopesOnSpan(span: Span | undefined, scope: Scope, isolationScope: Scope): void {\n  if (span) {\n    addNonEnumerableProperty(span, ISOLATION_SCOPE_ON_START_SPAN_FIELD, isolationScope);\n    addNonEnumerableProperty(span, SCOPE_ON_START_SPAN_FIELD, scope);\n  }\n}\n\n/**\n * Grabs the scope and isolation scope off a span that were active when the span was started.\n */\nexport function getCapturedScopesOnSpan(span: Span): { scope?: Scope; isolationScope?: Scope } {\n  return {\n    scope: (span as SpanWithScopes)[SCOPE_ON_START_SPAN_FIELD],\n    isolationScope: (span as SpanWithScopes)[ISOLATION_SCOPE_ON_START_SPAN_FIELD],\n  };\n}\n","import { createTransport } from '@sentry/core';\nimport type { Transport, TransportMakeRequestResponse, TransportRequest } from '@sentry/types';\nimport { SyncPromise } from '@sentry/utils';\n\nimport type { BrowserTransportOptions } from './types';\n\n/**\n * The DONE ready state for XmlHttpRequest\n *\n * Defining it here as a constant b/c XMLHttpRequest.DONE is not always defined\n * (e.g. during testing, it is `undefined`)\n *\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/readyState}\n */\nconst XHR_READYSTATE_DONE = 4;\n\n/**\n * Creates a Transport that uses the XMLHttpRequest API to send events to Sentry.\n */\nexport function makeXHRTransport(options: BrowserTransportOptions): Transport {\n  function makeRequest(request: TransportRequest): PromiseLike<TransportMakeRequestResponse> {\n    return new SyncPromise((resolve, reject) => {\n      const xhr = new XMLHttpRequest();\n\n      xhr.onerror = reject;\n\n      xhr.onreadystatechange = (): void => {\n        if (xhr.readyState === XHR_READYSTATE_DONE) {\n          resolve({\n            statusCode: xhr.status,\n            headers: {\n              'x-sentry-rate-limits': xhr.getResponseHeader('X-Sentry-Rate-Limits'),\n              'retry-after': xhr.getResponseHeader('Retry-After'),\n            },\n          });\n        }\n      };\n\n      xhr.open('POST', options.url);\n\n      for (const header in options.headers) {\n        if (Object.prototype.hasOwnProperty.call(options.headers, header)) {\n          xhr.setRequestHeader(header, options.headers[header]);\n        }\n      }\n\n      xhr.send(request.body);\n    });\n  }\n\n  return createTransport(options, makeRequest);\n}\n","import { convertIntegrationFnToClass, defineIntegration } from '@sentry/core';\nimport type { Event, Integration, IntegrationClass, IntegrationFn } from '@sentry/types';\n\nimport { WINDOW } from '../helpers';\n\nconst INTEGRATION_NAME = 'HttpContext';\n\nconst _httpContextIntegration = (() => {\n  return {\n    name: INTEGRATION_NAME,\n    // TODO v8: Remove this\n    setupOnce() {}, // eslint-disable-line @typescript-eslint/no-empty-function\n    preprocessEvent(event) {\n      // if none of the information we want exists, don't bother\n      if (!WINDOW.navigator && !WINDOW.location && !WINDOW.document) {\n        return;\n      }\n\n      // grab as much info as exists and add it to the event\n      const url = (event.request && event.request.url) || (WINDOW.location && WINDOW.location.href);\n      const { referrer } = WINDOW.document || {};\n      const { userAgent } = WINDOW.navigator || {};\n\n      const headers = {\n        ...(event.request && event.request.headers),\n        ...(referrer && { Referer: referrer }),\n        ...(userAgent && { 'User-Agent': userAgent }),\n      };\n      const request = { ...event.request, ...(url && { url }), headers };\n\n      event.request = request;\n    },\n  };\n}) satisfies IntegrationFn;\n\nexport const httpContextIntegration = defineIntegration(_httpContextIntegration);\n\n/**\n * HttpContext integration collects information about HTTP request headers.\n * @deprecated Use `httpContextIntegration()` instead.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport const HttpContext = convertIntegrationFnToClass(INTEGRATION_NAME, httpContextIntegration) as IntegrationClass<\n  Integration & { preprocessEvent: (event: Event) => void }\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\nimport { WINDOW } from '../../types';\n\nexport interface OnHiddenCallback {\n  (event: Event): void;\n}\n\nexport const onHidden = (cb: OnHiddenCallback, once?: boolean): void => {\n  const onHiddenOrPageHide = (event: Event): void => {\n    if (event.type === 'pagehide' || WINDOW.document!.visibilityState === 'hidden') {\n      cb(event);\n      if (once) {\n        removeEventListener('visibilitychange', onHiddenOrPageHide, true);\n        removeEventListener('pagehide', onHiddenOrPageHide, true);\n      }\n    }\n  };\n\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","import type { SerializedSession, Session, SessionContext, SessionStatus } from '@sentry/types';\nimport { dropUndefinedKeys, timestampInSeconds, uuid4 } from '@sentry/utils';\n/**\n * Creates a new `Session` object by setting certain default parameters. If optional @param context\n * is passed, the passed properties are applied to the session object.\n *\n * @param context (optional) additional properties to be applied to the returned session object\n *\n * @returns a new `Session` object\n */\nexport function makeSession(context?: Omit<SessionContext, 'started' | 'status'>): Session {\n  // Both timestamp and started are in seconds since the UNIX epoch.\n  const startingTime = timestampInSeconds();\n\n  const session: Session = {\n    sid: uuid4(),\n    init: true,\n    timestamp: startingTime,\n    started: startingTime,\n    duration: 0,\n    status: 'ok',\n    errors: 0,\n    ignoreDuration: false,\n    toJSON: () => sessionToJSON(session),\n  };\n\n  if (context) {\n    updateSession(session, context);\n  }\n\n  return session;\n}\n\n/**\n * Updates a session object with the properties passed in the context.\n *\n * Note that this function mutates the passed object and returns void.\n * (Had to do this instead of returning a new and updated session because closing and sending a session\n * makes an update to the session after it was passed to the sending logic.\n * @see BaseClient.captureSession )\n *\n * @param session the `Session` to update\n * @param context the `SessionContext` holding the properties that should be updated in @param session\n */\n// eslint-disable-next-line complexity\nexport function updateSession(session: Session, context: SessionContext = {}): void {\n  if (context.user) {\n    if (!session.ipAddress && context.user.ip_address) {\n      session.ipAddress = context.user.ip_address;\n    }\n\n    if (!session.did && !context.did) {\n      session.did = context.user.id || context.user.email || context.user.username;\n    }\n  }\n\n  session.timestamp = context.timestamp || timestampInSeconds();\n\n  if (context.abnormal_mechanism) {\n    session.abnormal_mechanism = context.abnormal_mechanism;\n  }\n\n  if (context.ignoreDuration) {\n    session.ignoreDuration = context.ignoreDuration;\n  }\n  if (context.sid) {\n    // Good enough uuid validation. — Kamil\n    session.sid = context.sid.length === 32 ? context.sid : uuid4();\n  }\n  if (context.init !== undefined) {\n    session.init = context.init;\n  }\n  if (!session.did && context.did) {\n    session.did = `${context.did}`;\n  }\n  if (typeof context.started === 'number') {\n    session.started = context.started;\n  }\n  if (session.ignoreDuration) {\n    session.duration = undefined;\n  } else if (typeof context.duration === 'number') {\n    session.duration = context.duration;\n  } else {\n    const duration = session.timestamp - session.started;\n    session.duration = duration >= 0 ? duration : 0;\n  }\n  if (context.release) {\n    session.release = context.release;\n  }\n  if (context.environment) {\n    session.environment = context.environment;\n  }\n  if (!session.ipAddress && context.ipAddress) {\n    session.ipAddress = context.ipAddress;\n  }\n  if (!session.userAgent && context.userAgent) {\n    session.userAgent = context.userAgent;\n  }\n  if (typeof context.errors === 'number') {\n    session.errors = context.errors;\n  }\n  if (context.status) {\n    session.status = context.status;\n  }\n}\n\n/**\n * Closes a session by setting its status and updating the session object with it.\n * Internally calls `updateSession` to update the passed session object.\n *\n * Note that this function mutates the passed session (@see updateSession for explanation).\n *\n * @param session the `Session` object to be closed\n * @param status the `SessionStatus` with which the session was closed. If you don't pass a status,\n *               this function will keep the previously set status, unless it was `'ok'` in which case\n *               it is changed to `'exited'`.\n */\nexport function closeSession(session: Session, status?: Exclude<SessionStatus, 'ok'>): void {\n  let context = {};\n  if (status) {\n    context = { status };\n  } else if (session.status === 'ok') {\n    context = { status: 'exited' };\n  }\n\n  updateSession(session, context);\n}\n\n/**\n * Serializes a passed session object to a JSON object with a slightly different structure.\n * This is necessary because the Sentry backend requires a slightly different schema of a session\n * than the one the JS SDKs use internally.\n *\n * @param session the session to be converted\n *\n * @returns a JSON object of the passed session\n */\nfunction sessionToJSON(session: Session): SerializedSession {\n  return dropUndefinedKeys({\n    sid: `${session.sid}`,\n    init: session.init,\n    // Make sure that sec is converted to ms for date constructor\n    started: new Date(session.started * 1000).toISOString(),\n    timestamp: new Date(session.timestamp * 1000).toISOString(),\n    status: session.status,\n    errors: session.errors,\n    did: typeof session.did === 'number' || typeof session.did === 'string' ? `${session.did}` : undefined,\n    duration: session.duration,\n    abnormal_mechanism: session.abnormal_mechanism,\n    attrs: {\n      release: session.release,\n      environment: session.environment,\n      ip_address: session.ipAddress,\n      user_agent: session.userAgent,\n    },\n  });\n}\n","// Based on https://github.com/angular/angular.js/pull/13945/files\n// The MIT License\n\n// Copyright (c) 2010-2016 Google, Inc. http://angularjs.org\n\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport { getGlobalObject } from '../worldwide';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject<Window>();\n\n/**\n * Tells whether current environment supports History API\n * {@link supportsHistory}.\n *\n * @returns Answer to the given question.\n */\nexport function supportsHistory(): boolean {\n  // NOTE: in Chrome App environment, touching history.pushState, *even inside\n  //       a try/catch block*, will cause Chrome to output an error to console.error\n  // borrowed from: https://github.com/angular/angular.js/pull/13945/files\n  /* eslint-disable @typescript-eslint/no-unsafe-member-access */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const chromeVar = (WINDOW as any).chrome;\n  const isChromePackagedApp = chromeVar && chromeVar.app && chromeVar.app.runtime;\n  /* eslint-enable @typescript-eslint/no-unsafe-member-access */\n  const hasHistoryApi = 'history' in WINDOW && !!WINDOW.history.pushState && !!WINDOW.history.replaceState;\n\n  return !isChromePackagedApp && hasHistoryApi;\n}\n","// TODO(v8): Move everything in this file into the browser package. Nothing here is generic and we run risk of leaking browser types into non-browser packages.\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/ban-types */\nimport type { HandlerDataHistory } from '@sentry/types';\n\nimport { fill } from '../object';\nimport { supportsHistory } from '../supports';\nimport { GLOBAL_OBJ } from '../worldwide';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers';\n\nconst WINDOW = GLOBAL_OBJ as unknown as Window;\n\nlet lastHref: string | undefined;\n\n/**\n * Add an instrumentation handler for when a fetch request happens.\n * The handler function is called once when the request starts and once when it ends,\n * which can be identified by checking if it has an `endTimestamp`.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addHistoryInstrumentationHandler(handler: (data: HandlerDataHistory) => void): void {\n  const type = 'history';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentHistory);\n}\n\nfunction instrumentHistory(): void {\n  if (!supportsHistory()) {\n    return;\n  }\n\n  const oldOnPopState = WINDOW.onpopstate;\n  WINDOW.onpopstate = function (this: WindowEventHandlers, ...args: any[]): any {\n    const to = WINDOW.location.href;\n    // keep track of the current URL state, as we always receive only the updated state\n    const from = lastHref;\n    lastHref = to;\n    const handlerData: HandlerDataHistory = { from, to };\n    triggerHandlers('history', handlerData);\n    if (oldOnPopState) {\n      // Apparently this can throw in Firefox when incorrectly implemented plugin is installed.\n      // https://github.com/getsentry/sentry-javascript/issues/3344\n      // https://github.com/bugsnag/bugsnag-js/issues/469\n      try {\n        return oldOnPopState.apply(this, args);\n      } catch (_oO) {\n        // no-empty\n      }\n    }\n  };\n\n  function historyReplacementFunction(originalHistoryFunction: () => void): () => void {\n    return function (this: History, ...args: any[]): void {\n      const url = args.length > 2 ? args[2] : undefined;\n      if (url) {\n        // coerce to string (this is what pushState does)\n        const from = lastHref;\n        const to = String(url);\n        // keep track of the current URL state, as we always receive only the updated state\n        lastHref = to;\n        const handlerData: HandlerDataHistory = { from, to };\n        triggerHandlers('history', handlerData);\n      }\n      return originalHistoryFunction.apply(this, args);\n    };\n  }\n\n  fill(WINDOW.history, 'pushState', historyReplacementFunction);\n  fill(WINDOW.history, 'replaceState', historyReplacementFunction);\n}\n","import type { Transaction } from '@sentry/types';\nimport { extractTraceparentData as _extractTraceparentData } from '@sentry/utils';\n\nimport type { Hub } from '../hub';\nimport { getCurrentHub } from '../hub';\n\n/**\n * Grabs active transaction off scope.\n *\n * @deprecated You should not rely on the transaction, but just use `startSpan()` APIs instead.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport function getActiveTransaction<T extends Transaction>(maybeHub?: Hub): T | undefined {\n  // eslint-disable-next-line deprecation/deprecation\n  const hub = maybeHub || getCurrentHub();\n  // eslint-disable-next-line deprecation/deprecation\n  const scope = hub.getScope();\n  // eslint-disable-next-line deprecation/deprecation\n  return scope.getTransaction() as T | undefined;\n}\n\n// so it can be used in manual instrumentation without necessitating a hard dependency on @sentry/utils\nexport { stripUrlQueryAndFragment } from '@sentry/utils';\n\n/**\n * The `extractTraceparentData` function and `TRACEPARENT_REGEXP` constant used\n * to be declared in this file. It was later moved into `@sentry/utils` as part of a\n * move to remove `@sentry/tracing` dependencies from `@sentry/node` (`extractTraceparentData`\n * is the only tracing function used by `@sentry/node`).\n *\n * These exports are kept here for backwards compatability's sake.\n *\n * See https://github.com/getsentry/sentry-javascript/issues/4642 for more details.\n *\n * @deprecated Import this function from `@sentry/utils` instead\n */\nexport const extractTraceparentData = _extractTraceparentData;\n","import type { StackFrame, StackLineParser, StackParser } from '@sentry/types';\n\nimport type { GetModuleFn } from './node-stack-trace';\nimport { filenameIsInApp, node } from './node-stack-trace';\n\nexport { filenameIsInApp };\n\nconst STACKTRACE_FRAME_LIMIT = 50;\n// Used to sanitize webpack (error: *) wrapped stack errors\nconst WEBPACK_ERROR_REGEXP = /\\(error: (.*)\\)/;\nconst STRIP_FRAME_REGEXP = /captureMessage|captureException/;\n\n/**\n * Creates a stack parser with the supplied line parsers\n *\n * StackFrames are returned in the correct order for Sentry Exception\n * frames and with Sentry SDK internal frames removed from the top and bottom\n *\n */\nexport function createStackParser(...parsers: StackLineParser[]): StackParser {\n  const sortedParsers = parsers.sort((a, b) => a[0] - b[0]).map(p => p[1]);\n\n  return (stack: string, skipFirst: number = 0): StackFrame[] => {\n    const frames: StackFrame[] = [];\n    const lines = stack.split('\\n');\n\n    for (let i = skipFirst; i < lines.length; i++) {\n      const line = lines[i];\n      // Ignore lines over 1kb as they are unlikely to be stack frames.\n      // Many of the regular expressions use backtracking which results in run time that increases exponentially with\n      // input size. Huge strings can result in hangs/Denial of Service:\n      // https://github.com/getsentry/sentry-javascript/issues/2286\n      if (line.length > 1024) {\n        continue;\n      }\n\n      // https://github.com/getsentry/sentry-javascript/issues/5459\n      // Remove webpack (error: *) wrappers\n      const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, '$1') : line;\n\n      // https://github.com/getsentry/sentry-javascript/issues/7813\n      // Skip Error: lines\n      if (cleanedLine.match(/\\S*Error: /)) {\n        continue;\n      }\n\n      for (const parser of sortedParsers) {\n        const frame = parser(cleanedLine);\n\n        if (frame) {\n          frames.push(frame);\n          break;\n        }\n      }\n\n      if (frames.length >= STACKTRACE_FRAME_LIMIT) {\n        break;\n      }\n    }\n\n    return stripSentryFramesAndReverse(frames);\n  };\n}\n\n/**\n * Gets a stack parser implementation from Options.stackParser\n * @see Options\n *\n * If options contains an array of line parsers, it is converted into a parser\n */\nexport function stackParserFromStackParserOptions(stackParser: StackParser | StackLineParser[]): StackParser {\n  if (Array.isArray(stackParser)) {\n    return createStackParser(...stackParser);\n  }\n  return stackParser;\n}\n\n/**\n * Removes Sentry frames from the top and bottom of the stack if present and enforces a limit of max number of frames.\n * Assumes stack input is ordered from top to bottom and returns the reverse representation so call site of the\n * function that caused the crash is the last frame in the array.\n * @hidden\n */\nexport function stripSentryFramesAndReverse(stack: ReadonlyArray<StackFrame>): StackFrame[] {\n  if (!stack.length) {\n    return [];\n  }\n\n  const localStack = Array.from(stack);\n\n  // If stack starts with one of our API calls, remove it (starts, meaning it's the top of the stack - aka last call)\n  if (/sentryWrapped/.test(localStack[localStack.length - 1].function || '')) {\n    localStack.pop();\n  }\n\n  // Reversing in the middle of the procedure allows us to just pop the values off the stack\n  localStack.reverse();\n\n  // If stack ends with one of our internal API calls, remove it (ends, meaning it's the bottom of the stack - aka top-most call)\n  if (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || '')) {\n    localStack.pop();\n\n    // When using synthetic events, we will have a 2 levels deep stack, as `new Error('Sentry syntheticException')`\n    // is produced within the hub itself, making it:\n    //\n    //   Sentry.captureException()\n    //   getCurrentHub().captureException()\n    //\n    // instead of just the top `Sentry` call itself.\n    // This forces us to possibly strip an additional frame in the exact same was as above.\n    if (STRIP_FRAME_REGEXP.test(localStack[localStack.length - 1].function || '')) {\n      localStack.pop();\n    }\n  }\n\n  return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map(frame => ({\n    ...frame,\n    filename: frame.filename || localStack[localStack.length - 1].filename,\n    function: frame.function || '?',\n  }));\n}\n\nconst defaultFunctionName = '<anonymous>';\n\n/**\n * Safely extract function name from itself\n */\nexport function getFunctionName(fn: unknown): string {\n  try {\n    if (!fn || typeof fn !== 'function') {\n      return defaultFunctionName;\n    }\n    return fn.name || defaultFunctionName;\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    return defaultFunctionName;\n  }\n}\n\n/**\n * Node.js stack line parser\n *\n * This is in @sentry/utils so it can be used from the Electron SDK in the browser for when `nodeIntegration == true`.\n * This allows it to be used without referencing or importing any node specific code which causes bundlers to complain\n */\nexport function nodeStackLineParser(getModule?: GetModuleFn): StackLineParser {\n  return [90, node(getModule)];\n}\n","import type { Client, Event, EventHint, Integration, IntegrationClass, IntegrationFn, StackFrame } from '@sentry/types';\nimport { getEventDescription, logger, stringMatchesSomePattern } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport { convertIntegrationFnToClass, defineIntegration } from '../integration';\n\n// \"Script error.\" is hard coded into browsers for errors that it can't read.\n// this is the result of a script being pulled in from an external domain and CORS.\nconst DEFAULT_IGNORE_ERRORS = [\n  /^Script error\\.?$/,\n  /^Javascript error: Script error\\.? on line 0$/,\n  /^ResizeObserver loop completed with undelivered notifications.$/,\n  /^Cannot redefine property: googletag$/,\n];\n\nconst DEFAULT_IGNORE_TRANSACTIONS = [\n  /^.*\\/healthcheck$/,\n  /^.*\\/healthy$/,\n  /^.*\\/live$/,\n  /^.*\\/ready$/,\n  /^.*\\/heartbeat$/,\n  /^.*\\/health$/,\n  /^.*\\/healthz$/,\n];\n\n/** Options for the InboundFilters integration */\nexport interface InboundFiltersOptions {\n  allowUrls: Array<string | RegExp>;\n  denyUrls: Array<string | RegExp>;\n  ignoreErrors: Array<string | RegExp>;\n  ignoreTransactions: Array<string | RegExp>;\n  ignoreInternal: boolean;\n  disableErrorDefaults: boolean;\n  disableTransactionDefaults: boolean;\n}\n\nconst INTEGRATION_NAME = 'InboundFilters';\nconst _inboundFiltersIntegration = ((options: Partial<InboundFiltersOptions> = {}) => {\n  return {\n    name: INTEGRATION_NAME,\n    // TODO v8: Remove this\n    setupOnce() {}, // eslint-disable-line @typescript-eslint/no-empty-function\n    processEvent(event, _hint, client) {\n      const clientOptions = client.getOptions();\n      const mergedOptions = _mergeOptions(options, clientOptions);\n      return _shouldDropEvent(event, mergedOptions) ? null : event;\n    },\n  };\n}) satisfies IntegrationFn;\n\nexport const inboundFiltersIntegration = defineIntegration(_inboundFiltersIntegration);\n\n/**\n * Inbound filters configurable by the user.\n * @deprecated Use `inboundFiltersIntegration()` instead.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport const InboundFilters = convertIntegrationFnToClass(\n  INTEGRATION_NAME,\n  inboundFiltersIntegration,\n) as IntegrationClass<Integration & { preprocessEvent: (event: Event, hint: EventHint, client: Client) => void }> & {\n  new (\n    options?: Partial<{\n      allowUrls: Array<string | RegExp>;\n      denyUrls: Array<string | RegExp>;\n      ignoreErrors: Array<string | RegExp>;\n      ignoreTransactions: Array<string | RegExp>;\n      ignoreInternal: boolean;\n      disableErrorDefaults: boolean;\n      disableTransactionDefaults: boolean;\n    }>,\n  ): Integration;\n};\n\nfunction _mergeOptions(\n  internalOptions: Partial<InboundFiltersOptions> = {},\n  clientOptions: Partial<InboundFiltersOptions> = {},\n): Partial<InboundFiltersOptions> {\n  return {\n    allowUrls: [...(internalOptions.allowUrls || []), ...(clientOptions.allowUrls || [])],\n    denyUrls: [...(internalOptions.denyUrls || []), ...(clientOptions.denyUrls || [])],\n    ignoreErrors: [\n      ...(internalOptions.ignoreErrors || []),\n      ...(clientOptions.ignoreErrors || []),\n      ...(internalOptions.disableErrorDefaults ? [] : DEFAULT_IGNORE_ERRORS),\n    ],\n    ignoreTransactions: [\n      ...(internalOptions.ignoreTransactions || []),\n      ...(clientOptions.ignoreTransactions || []),\n      ...(internalOptions.disableTransactionDefaults ? [] : DEFAULT_IGNORE_TRANSACTIONS),\n    ],\n    ignoreInternal: internalOptions.ignoreInternal !== undefined ? internalOptions.ignoreInternal : true,\n  };\n}\n\nfunction _shouldDropEvent(event: Event, options: Partial<InboundFiltersOptions>): boolean {\n  if (options.ignoreInternal && _isSentryError(event)) {\n    DEBUG_BUILD &&\n      logger.warn(`Event dropped due to being internal Sentry Error.\\nEvent: ${getEventDescription(event)}`);\n    return true;\n  }\n  if (_isIgnoredError(event, options.ignoreErrors)) {\n    DEBUG_BUILD &&\n      logger.warn(\n        `Event dropped due to being matched by \\`ignoreErrors\\` option.\\nEvent: ${getEventDescription(event)}`,\n      );\n    return true;\n  }\n  if (_isIgnoredTransaction(event, options.ignoreTransactions)) {\n    DEBUG_BUILD &&\n      logger.warn(\n        `Event dropped due to being matched by \\`ignoreTransactions\\` option.\\nEvent: ${getEventDescription(event)}`,\n      );\n    return true;\n  }\n  if (_isDeniedUrl(event, options.denyUrls)) {\n    DEBUG_BUILD &&\n      logger.warn(\n        `Event dropped due to being matched by \\`denyUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n      );\n    return true;\n  }\n  if (!_isAllowedUrl(event, options.allowUrls)) {\n    DEBUG_BUILD &&\n      logger.warn(\n        `Event dropped due to not being matched by \\`allowUrls\\` option.\\nEvent: ${getEventDescription(\n          event,\n        )}.\\nUrl: ${_getEventFilterUrl(event)}`,\n      );\n    return true;\n  }\n  return false;\n}\n\nfunction _isIgnoredError(event: Event, ignoreErrors?: Array<string | RegExp>): boolean {\n  // If event.type, this is not an error\n  if (event.type || !ignoreErrors || !ignoreErrors.length) {\n    return false;\n  }\n\n  return _getPossibleEventMessages(event).some(message => stringMatchesSomePattern(message, ignoreErrors));\n}\n\nfunction _isIgnoredTransaction(event: Event, ignoreTransactions?: Array<string | RegExp>): boolean {\n  if (event.type !== 'transaction' || !ignoreTransactions || !ignoreTransactions.length) {\n    return false;\n  }\n\n  const name = event.transaction;\n  return name ? stringMatchesSomePattern(name, ignoreTransactions) : false;\n}\n\nfunction _isDeniedUrl(event: Event, denyUrls?: Array<string | RegExp>): boolean {\n  // TODO: Use Glob instead?\n  if (!denyUrls || !denyUrls.length) {\n    return false;\n  }\n  const url = _getEventFilterUrl(event);\n  return !url ? false : stringMatchesSomePattern(url, denyUrls);\n}\n\nfunction _isAllowedUrl(event: Event, allowUrls?: Array<string | RegExp>): boolean {\n  // TODO: Use Glob instead?\n  if (!allowUrls || !allowUrls.length) {\n    return true;\n  }\n  const url = _getEventFilterUrl(event);\n  return !url ? true : stringMatchesSomePattern(url, allowUrls);\n}\n\nfunction _getPossibleEventMessages(event: Event): string[] {\n  const possibleMessages: string[] = [];\n\n  if (event.message) {\n    possibleMessages.push(event.message);\n  }\n\n  let lastException;\n  try {\n    // @ts-expect-error Try catching to save bundle size\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    lastException = event.exception.values[event.exception.values.length - 1];\n  } catch (e) {\n    // try catching to save bundle size checking existence of variables\n  }\n\n  if (lastException) {\n    if (lastException.value) {\n      possibleMessages.push(lastException.value);\n      if (lastException.type) {\n        possibleMessages.push(`${lastException.type}: ${lastException.value}`);\n      }\n    }\n  }\n\n  if (DEBUG_BUILD && possibleMessages.length === 0) {\n    logger.error(`Could not extract message for event ${getEventDescription(event)}`);\n  }\n\n  return possibleMessages;\n}\n\nfunction _isSentryError(event: Event): boolean {\n  try {\n    // @ts-expect-error can't be a sentry error if undefined\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    return event.exception.values[0].type === 'SentryError';\n  } catch (e) {\n    // ignore\n  }\n  return false;\n}\n\nfunction _getLastValidUrl(frames: StackFrame[] = []): string | null {\n  for (let i = frames.length - 1; i >= 0; i--) {\n    const frame = frames[i];\n\n    if (frame && frame.filename !== '<anonymous>' && frame.filename !== '[native code]') {\n      return frame.filename || null;\n    }\n  }\n\n  return null;\n}\n\nfunction _getEventFilterUrl(event: Event): string | null {\n  try {\n    let frames;\n    try {\n      // @ts-expect-error we only care about frames if the whole thing here is defined\n      frames = event.exception.values[0].stacktrace.frames;\n    } catch (e) {\n      // ignore\n    }\n    return frames ? _getLastValidUrl(frames) : null;\n  } catch (oO) {\n    DEBUG_BUILD && logger.error(`Cannot extract url for event ${getEventDescription(event)}`);\n    return null;\n  }\n}\n","// TODO(v8): Move everything in this file into the browser package. Nothing here is generic and we run risk of leaking browser types into non-browser packages.\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/ban-types */\nimport type { HandlerDataXhr, SentryWrappedXMLHttpRequest, WrappedFunction } from '@sentry/types';\n\nimport { isString } from '../is';\nimport { fill } from '../object';\nimport { GLOBAL_OBJ } from '../worldwide';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers';\n\nconst WINDOW = GLOBAL_OBJ as unknown as Window;\n\nexport const SENTRY_XHR_DATA_KEY = '__sentry_xhr_v3__';\n\n/**\n * Add an instrumentation handler for when an XHR request happens.\n * The handler function is called once when the request starts and once when it ends,\n * which can be identified by checking if it has an `endTimestamp`.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addXhrInstrumentationHandler(handler: (data: HandlerDataXhr) => void): void {\n  const type = 'xhr';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentXHR);\n}\n\n/** Exported only for tests. */\nexport function instrumentXHR(): void {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  if (!(WINDOW as any).XMLHttpRequest) {\n    return;\n  }\n\n  const xhrproto = XMLHttpRequest.prototype;\n\n  fill(xhrproto, 'open', function (originalOpen: () => void): () => void {\n    return function (this: XMLHttpRequest & SentryWrappedXMLHttpRequest, ...args: any[]): void {\n      const startTimestamp = Date.now();\n\n      // open() should always be called with two or more arguments\n      // But to be on the safe side, we actually validate this and bail out if we don't have a method & url\n      const method = isString(args[0]) ? args[0].toUpperCase() : undefined;\n      const url = parseUrl(args[1]);\n\n      if (!method || !url) {\n        return originalOpen.apply(this, args);\n      }\n\n      this[SENTRY_XHR_DATA_KEY] = {\n        method,\n        url,\n        request_headers: {},\n      };\n\n      // if Sentry key appears in URL, don't capture it as a request\n      if (method === 'POST' && url.match(/sentry_key/)) {\n        this.__sentry_own_request__ = true;\n      }\n\n      const onreadystatechangeHandler: () => void = () => {\n        // For whatever reason, this is not the same instance here as from the outer method\n        const xhrInfo = this[SENTRY_XHR_DATA_KEY];\n\n        if (!xhrInfo) {\n          return;\n        }\n\n        if (this.readyState === 4) {\n          try {\n            // touching statusCode in some platforms throws\n            // an exception\n            xhrInfo.status_code = this.status;\n          } catch (e) {\n            /* do nothing */\n          }\n\n          const handlerData: HandlerDataXhr = {\n            args: [method, url],\n            endTimestamp: Date.now(),\n            startTimestamp,\n            xhr: this,\n          };\n          triggerHandlers('xhr', handlerData);\n        }\n      };\n\n      if ('onreadystatechange' in this && typeof this.onreadystatechange === 'function') {\n        fill(this, 'onreadystatechange', function (original: WrappedFunction): Function {\n          return function (this: SentryWrappedXMLHttpRequest, ...readyStateArgs: any[]): void {\n            onreadystatechangeHandler();\n            return original.apply(this, readyStateArgs);\n          };\n        });\n      } else {\n        this.addEventListener('readystatechange', onreadystatechangeHandler);\n      }\n\n      // Intercepting `setRequestHeader` to access the request headers of XHR instance.\n      // This will only work for user/library defined headers, not for the default/browser-assigned headers.\n      // Request cookies are also unavailable for XHR, as `Cookie` header can't be defined by `setRequestHeader`.\n      fill(this, 'setRequestHeader', function (original: WrappedFunction): Function {\n        return function (this: SentryWrappedXMLHttpRequest, ...setRequestHeaderArgs: unknown[]): void {\n          const [header, value] = setRequestHeaderArgs;\n\n          const xhrInfo = this[SENTRY_XHR_DATA_KEY];\n\n          if (xhrInfo && isString(header) && isString(value)) {\n            xhrInfo.request_headers[header.toLowerCase()] = value;\n          }\n\n          return original.apply(this, setRequestHeaderArgs);\n        };\n      });\n\n      return originalOpen.apply(this, args);\n    };\n  });\n\n  fill(xhrproto, 'send', function (originalSend: () => void): () => void {\n    return function (this: XMLHttpRequest & SentryWrappedXMLHttpRequest, ...args: any[]): void {\n      const sentryXhrData = this[SENTRY_XHR_DATA_KEY];\n\n      if (!sentryXhrData) {\n        return originalSend.apply(this, args);\n      }\n\n      if (args[0] !== undefined) {\n        sentryXhrData.body = args[0];\n      }\n\n      const handlerData: HandlerDataXhr = {\n        args: [sentryXhrData.method, sentryXhrData.url],\n        startTimestamp: Date.now(),\n        xhr: this,\n      };\n      triggerHandlers('xhr', handlerData);\n\n      return originalSend.apply(this, args);\n    };\n  });\n}\n\nfunction parseUrl(url: string | unknown): string | undefined {\n  if (isString(url)) {\n    return url;\n  }\n\n  try {\n    // url can be a string or URL\n    // but since URL is not available in IE11, we do not check for it,\n    // but simply assume it is an URL and return `toString()` from it (which returns the full URL)\n    // If that fails, we just return undefined\n    return (url as URL).toString();\n  } catch {} // eslint-disable-line no-empty\n\n  return undefined;\n}\n","import { GLOBAL_OBJ } from '@sentry/utils';\n\nexport const WINDOW = GLOBAL_OBJ as typeof GLOBAL_OBJ &\n  // document is not available in all browser environments (webworkers). We make it optional so you have to explicitly check for it\n  Omit<Window, 'document'> &\n  Partial<Pick<Window, 'document'>>;\n","/* eslint-disable @typescript-eslint/explicit-function-return-type */\n/* eslint-disable @typescript-eslint/typedef */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { isThenable } from './is';\n\n/** SyncPromise internal states */\nconst enum States {\n  /** Pending */\n  PENDING = 0,\n  /** Resolved / OK */\n  RESOLVED = 1,\n  /** Rejected / Error */\n  REJECTED = 2,\n}\n\n// Overloads so we can call resolvedSyncPromise without arguments and generic argument\nexport function resolvedSyncPromise(): PromiseLike<void>;\nexport function resolvedSyncPromise<T>(value: T | PromiseLike<T>): PromiseLike<T>;\n\n/**\n * Creates a resolved sync promise.\n *\n * @param value the value to resolve the promise with\n * @returns the resolved sync promise\n */\nexport function resolvedSyncPromise<T>(value?: T | PromiseLike<T>): PromiseLike<T> {\n  return new SyncPromise(resolve => {\n    resolve(value);\n  });\n}\n\n/**\n * Creates a rejected sync promise.\n *\n * @param value the value to reject the promise with\n * @returns the rejected sync promise\n */\nexport function rejectedSyncPromise<T = never>(reason?: any): PromiseLike<T> {\n  return new SyncPromise((_, reject) => {\n    reject(reason);\n  });\n}\n\n/**\n * Thenable class that behaves like a Promise and follows it's interface\n * but is not async internally\n */\nclass SyncPromise<T> implements PromiseLike<T> {\n  private _state: States;\n  private _handlers: Array<[boolean, (value: T) => void, (reason: any) => any]>;\n  private _value: any;\n\n  public constructor(\n    executor: (resolve: (value?: T | PromiseLike<T> | null) => void, reject: (reason?: any) => void) => void,\n  ) {\n    this._state = States.PENDING;\n    this._handlers = [];\n\n    try {\n      executor(this._resolve, this._reject);\n    } catch (e) {\n      this._reject(e);\n    }\n  }\n\n  /** JSDoc */\n  public then<TResult1 = T, TResult2 = never>(\n    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,\n    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,\n  ): PromiseLike<TResult1 | TResult2> {\n    return new SyncPromise((resolve, reject) => {\n      this._handlers.push([\n        false,\n        result => {\n          if (!onfulfilled) {\n            // TODO: ¯\\_(ツ)_/¯\n            // TODO: FIXME\n            resolve(result as any);\n          } else {\n            try {\n              resolve(onfulfilled(result));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n        reason => {\n          if (!onrejected) {\n            reject(reason);\n          } else {\n            try {\n              resolve(onrejected(reason));\n            } catch (e) {\n              reject(e);\n            }\n          }\n        },\n      ]);\n      this._executeHandlers();\n    });\n  }\n\n  /** JSDoc */\n  public catch<TResult = never>(\n    onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null,\n  ): PromiseLike<T | TResult> {\n    return this.then(val => val, onrejected);\n  }\n\n  /** JSDoc */\n  public finally<TResult>(onfinally?: (() => void) | null): PromiseLike<TResult> {\n    return new SyncPromise<TResult>((resolve, reject) => {\n      let val: TResult | any;\n      let isRejected: boolean;\n\n      return this.then(\n        value => {\n          isRejected = false;\n          val = value;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n        reason => {\n          isRejected = true;\n          val = reason;\n          if (onfinally) {\n            onfinally();\n          }\n        },\n      ).then(() => {\n        if (isRejected) {\n          reject(val);\n          return;\n        }\n\n        resolve(val as unknown as any);\n      });\n    });\n  }\n\n  /** JSDoc */\n  private readonly _resolve = (value?: T | PromiseLike<T> | null) => {\n    this._setResult(States.RESOLVED, value);\n  };\n\n  /** JSDoc */\n  private readonly _reject = (reason?: any) => {\n    this._setResult(States.REJECTED, reason);\n  };\n\n  /** JSDoc */\n  private readonly _setResult = (state: States, value?: T | PromiseLike<T> | any) => {\n    if (this._state !== States.PENDING) {\n      return;\n    }\n\n    if (isThenable(value)) {\n      void (value as PromiseLike<T>).then(this._resolve, this._reject);\n      return;\n    }\n\n    this._state = state;\n    this._value = value;\n\n    this._executeHandlers();\n  };\n\n  /** JSDoc */\n  private readonly _executeHandlers = () => {\n    if (this._state === States.PENDING) {\n      return;\n    }\n\n    const cachedHandlers = this._handlers.slice();\n    this._handlers = [];\n\n    cachedHandlers.forEach(handler => {\n      if (handler[0]) {\n        return;\n      }\n\n      if (this._state === States.RESOLVED) {\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        handler[1](this._value as unknown as any);\n      }\n\n      if (this._state === States.REJECTED) {\n        handler[2](this._value);\n      }\n\n      handler[0] = true;\n    });\n  };\n}\n\nexport { SyncPromise };\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\nimport { WINDOW } from '../../types';\nimport type { NavigationTimingPolyfillEntry } from '../types';\n\nconst getNavigationEntryFromPerformanceTiming = (): NavigationTimingPolyfillEntry => {\n  // eslint-disable-next-line deprecation/deprecation\n  const timing = WINDOW.performance.timing;\n  // eslint-disable-next-line deprecation/deprecation\n  const type = WINDOW.performance.navigation.type;\n\n  const navigationEntry: { [key: string]: number | string } = {\n    entryType: 'navigation',\n    startTime: 0,\n    type: type == 2 ? 'back_forward' : type === 1 ? 'reload' : 'navigate',\n  };\n\n  for (const key in timing) {\n    if (key !== 'navigationStart' && key !== 'toJSON') {\n      // eslint-disable-next-line deprecation/deprecation\n      navigationEntry[key] = Math.max((timing[key as keyof PerformanceTiming] as number) - timing.navigationStart, 0);\n    }\n  }\n  return navigationEntry as unknown as NavigationTimingPolyfillEntry;\n};\n\nexport const getNavigationEntry = (): PerformanceNavigationTiming | NavigationTimingPolyfillEntry | undefined => {\n  if (WINDOW.__WEB_VITALS_POLYFILL__) {\n    return (\n      WINDOW.performance &&\n      ((performance.getEntriesByType && performance.getEntriesByType('navigation')[0]) ||\n        getNavigationEntryFromPerformanceTiming())\n    );\n  } else {\n    return WINDOW.performance && performance.getEntriesByType && performance.getEntriesByType('navigation')[0];\n  }\n};\n","declare const __DEBUG_BUILD__: boolean;\n\n/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nexport const DEBUG_BUILD = __DEBUG_BUILD__;\n","/**\n * Use this attribute to represent the source of a span.\n * Should be one of: custom, url, route, view, component, task, unknown\n *\n */\nexport const SEMANTIC_ATTRIBUTE_SENTRY_SOURCE = 'sentry.source';\n\n/**\n * Use this attribute to represent the sample rate used for a span.\n */\nexport const SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE = 'sentry.sample_rate';\n\n/**\n * Use this attribute to represent the operation of a span.\n */\nexport const SEMANTIC_ATTRIBUTE_SENTRY_OP = 'sentry.op';\n\n/**\n * Use this attribute to represent the origin of a span.\n */\nexport const SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN = 'sentry.origin';\n\n/**\n * The id of the profile that this span occured in.\n */\nexport const SEMANTIC_ATTRIBUTE_PROFILE_ID = 'profile_id';\n","import type { HandlerDataError } from '@sentry/types';\n\nimport { GLOBAL_OBJ } from '../worldwide';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers';\n\nlet _oldOnErrorHandler: (typeof GLOBAL_OBJ)['onerror'] | null = null;\n\n/**\n * Add an instrumentation handler for when an error is captured by the global error handler.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addGlobalErrorInstrumentationHandler(handler: (data: HandlerDataError) => void): void {\n  const type = 'error';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentError);\n}\n\nfunction instrumentError(): void {\n  _oldOnErrorHandler = GLOBAL_OBJ.onerror;\n\n  GLOBAL_OBJ.onerror = function (\n    msg: string | object,\n    url?: string,\n    line?: number,\n    column?: number,\n    error?: Error,\n  ): boolean {\n    const handlerData: HandlerDataError = {\n      column,\n      error,\n      line,\n      msg,\n      url,\n    };\n    triggerHandlers('error', handlerData);\n\n    if (_oldOnErrorHandler && !_oldOnErrorHandler.__SENTRY_LOADER__) {\n      // eslint-disable-next-line prefer-rest-params\n      return _oldOnErrorHandler.apply(this, arguments);\n    }\n\n    return false;\n  };\n\n  GLOBAL_OBJ.onerror.__SENTRY_INSTRUMENTED__ = true;\n}\n","// This was originally forked from https://github.com/csnover/TraceKit, and was largely\n// re - written as part of raven - js.\n//\n// This code was later copied to the JavaScript mono - repo and further modified and\n// refactored over the years.\n\n// Copyright (c) 2013 Onur Can Cakmak onur.cakmak@gmail.com and all TraceKit contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of this\n// software and associated documentation files(the 'Software'), to deal in the Software\n// without restriction, including without limitation the rights to use, copy, modify,\n// merge, publish, distribute, sublicense, and / or sell copies of the Software, and to\n// permit persons to whom the Software is furnished to do so, subject to the following\n// conditions:\n//\n// The above copyright notice and this permission notice shall be included in all copies\n// or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,\n// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\n// PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF\n// CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE\n// OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nimport type { StackFrame, StackLineParser, StackLineParserFn } from '@sentry/types';\nimport { createStackParser } from '@sentry/utils';\n\n// global reference to slice\nconst UNKNOWN_FUNCTION = '?';\n\nconst OPERA10_PRIORITY = 10;\nconst OPERA11_PRIORITY = 20;\nconst CHROME_PRIORITY = 30;\nconst WINJS_PRIORITY = 40;\nconst GECKO_PRIORITY = 50;\n\nfunction createFrame(filename: string, func: string, lineno?: number, colno?: number): StackFrame {\n  const frame: StackFrame = {\n    filename,\n    function: func,\n    in_app: true, // All browser frames are considered in_app\n  };\n\n  if (lineno !== undefined) {\n    frame.lineno = lineno;\n  }\n\n  if (colno !== undefined) {\n    frame.colno = colno;\n  }\n\n  return frame;\n}\n\n// Chromium based browsers: Chrome, Brave, new Opera, new Edge\nconst chromeRegex =\n  /^\\s*at (?:(.+?\\)(?: \\[.+\\])?|.*?) ?\\((?:address at )?)?(?:async )?((?:<anonymous>|[-a-z]+:|.*bundle|\\/)?.*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\nconst chromeEvalRegex = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\n\n// We cannot call this variable `chrome` because it can conflict with global `chrome` variable in certain environments\n// See: https://github.com/getsentry/sentry-javascript/issues/6880\nconst chromeStackParserFn: StackLineParserFn = line => {\n  const parts = chromeRegex.exec(line);\n\n  if (parts) {\n    const isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n\n    if (isEval) {\n      const subMatch = chromeEvalRegex.exec(parts[2]);\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line/column number\n        parts[2] = subMatch[1]; // url\n        parts[3] = subMatch[2]; // line\n        parts[4] = subMatch[3]; // column\n      }\n    }\n\n    // Kamil: One more hack won't hurt us right? Understanding and adding more rules on top of these regexps right now\n    // would be way too time consuming. (TODO: Rewrite whole RegExp to be more readable)\n    const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);\n\n    return createFrame(filename, func, parts[3] ? +parts[3] : undefined, parts[4] ? +parts[4] : undefined);\n  }\n\n  return;\n};\n\nexport const chromeStackLineParser: StackLineParser = [CHROME_PRIORITY, chromeStackParserFn];\n\n// gecko regex: `(?:bundle|\\d+\\.js)`: `bundle` is for react native, `\\d+\\.js` also but specifically for ram bundles because it\n// generates filenames without a prefix like `file://` the filenames in the stacktrace are just 42.js\n// We need this specific case for now because we want no other regex to match.\nconst geckoREgex =\n  /^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)?((?:[-a-z]+)?:\\/.*?|\\[native code\\]|[^@]*(?:bundle|\\d+\\.js)|\\/[\\w\\-. /=]+)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nconst geckoEvalRegex = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\n\nconst gecko: StackLineParserFn = line => {\n  const parts = geckoREgex.exec(line);\n\n  if (parts) {\n    const isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    if (isEval) {\n      const subMatch = geckoEvalRegex.exec(parts[3]);\n\n      if (subMatch) {\n        // throw out eval line/column and use top-most line number\n        parts[1] = parts[1] || 'eval';\n        parts[3] = subMatch[1];\n        parts[4] = subMatch[2];\n        parts[5] = ''; // no column when eval\n      }\n    }\n\n    let filename = parts[3];\n    let func = parts[1] || UNKNOWN_FUNCTION;\n    [func, filename] = extractSafariExtensionDetails(func, filename);\n\n    return createFrame(filename, func, parts[4] ? +parts[4] : undefined, parts[5] ? +parts[5] : undefined);\n  }\n\n  return;\n};\n\nexport const geckoStackLineParser: StackLineParser = [GECKO_PRIORITY, gecko];\n\nconst winjsRegex = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:[-a-z]+):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\n\nconst winjs: StackLineParserFn = line => {\n  const parts = winjsRegex.exec(line);\n\n  return parts\n    ? createFrame(parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined)\n    : undefined;\n};\n\nexport const winjsStackLineParser: StackLineParser = [WINJS_PRIORITY, winjs];\n\nconst opera10Regex = / line (\\d+).*script (?:in )?(\\S+)(?:: in function (\\S+))?$/i;\n\nconst opera10: StackLineParserFn = line => {\n  const parts = opera10Regex.exec(line);\n  return parts ? createFrame(parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;\n};\n\nexport const opera10StackLineParser: StackLineParser = [OPERA10_PRIORITY, opera10];\n\nconst opera11Regex =\n  / line (\\d+), column (\\d+)\\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\\(.*\\))? in (.*):\\s*$/i;\n\nconst opera11: StackLineParserFn = line => {\n  const parts = opera11Regex.exec(line);\n  return parts ? createFrame(parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : undefined;\n};\n\nexport const opera11StackLineParser: StackLineParser = [OPERA11_PRIORITY, opera11];\n\nexport const defaultStackLineParsers = [chromeStackLineParser, geckoStackLineParser, winjsStackLineParser];\n\nexport const defaultStackParser = createStackParser(...defaultStackLineParsers);\n\n/**\n * Safari web extensions, starting version unknown, can produce \"frames-only\" stacktraces.\n * What it means, is that instead of format like:\n *\n * Error: wat\n *   at function@url:row:col\n *   at function@url:row:col\n *   at function@url:row:col\n *\n * it produces something like:\n *\n *   function@url:row:col\n *   function@url:row:col\n *   function@url:row:col\n *\n * Because of that, it won't be captured by `chrome` RegExp and will fall into `Gecko` branch.\n * This function is extracted so that we can use it in both places without duplicating the logic.\n * Unfortunately \"just\" changing RegExp is too complicated now and making it pass all tests\n * and fix this case seems like an impossible, or at least way too time-consuming task.\n */\nconst extractSafariExtensionDetails = (func: string, filename: string): [string, string] => {\n  const isSafariExtension = func.indexOf('safari-extension') !== -1;\n  const isSafariWebExtension = func.indexOf('safari-web-extension') !== -1;\n\n  return isSafariExtension || isSafariWebExtension\n    ? [\n        func.indexOf('@') !== -1 ? func.split('@')[0] : UNKNOWN_FUNCTION,\n        isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`,\n      ]\n    : [func, filename];\n};\n","type PartialURL = {\n  host?: string;\n  path?: string;\n  protocol?: string;\n  relative?: string;\n  search?: string;\n  hash?: string;\n};\n\n/**\n * Parses string form of URL into an object\n * // borrowed from https://tools.ietf.org/html/rfc3986#appendix-B\n * // intentionally using regex and not <a/> href parsing trick because React Native and other\n * // environments where DOM might not be available\n * @returns parsed URL object\n */\nexport function parseUrl(url: string): PartialURL {\n  if (!url) {\n    return {};\n  }\n\n  const match = url.match(/^(([^:/?#]+):)?(\\/\\/([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$/);\n\n  if (!match) {\n    return {};\n  }\n\n  // coerce to undefined values to empty string so we don't get 'undefined'\n  const query = match[6] || '';\n  const fragment = match[8] || '';\n  return {\n    host: match[4],\n    path: match[5],\n    protocol: match[2],\n    search: query,\n    hash: fragment,\n    relative: match[5] + query + fragment, // everything minus origin\n  };\n}\n\n/**\n * Strip the query string and fragment off of a given URL or path (if present)\n *\n * @param urlPath Full URL or path, including possible query string and/or fragment\n * @returns URL or path without query string or fragment\n */\nexport function stripUrlQueryAndFragment(urlPath: string): string {\n  // eslint-disable-next-line no-useless-escape\n  return urlPath.split(/[\\?#]/, 1)[0];\n}\n\n/**\n * Returns number of URL segments of a passed string URL.\n */\nexport function getNumberOfUrlSegments(url: string): number {\n  // split at '/' or at '\\/' to split regex urls correctly\n  return url.split(/\\\\?\\//).filter(s => s.length > 0 && s !== ',').length;\n}\n\n/**\n * Takes a URL object and returns a sanitized string which is safe to use as span description\n * see: https://develop.sentry.dev/sdk/data-handling/#structuring-data\n */\nexport function getSanitizedUrlString(url: PartialURL): string {\n  const { protocol, host, path } = url;\n\n  const filteredHost =\n    (host &&\n      host\n        // Always filter out authority\n        .replace(/^.*@/, '[filtered]:[filtered]@')\n        // Don't show standard :80 (http) and :443 (https) ports to reduce the noise\n        // TODO: Use new URL global if it exists\n        .replace(/(:80)$/, '')\n        .replace(/(:443)$/, '')) ||\n    '';\n\n  return `${protocol ? `${protocol}://` : ''}${filteredHost}${path}`;\n}\n","import type {\n  CaptureContext,\n  Client,\n  ClientOptions,\n  Event,\n  EventHint,\n  Scope as ScopeInterface,\n  ScopeContext,\n  StackFrame,\n  StackParser,\n} from '@sentry/types';\nimport { GLOBAL_OBJ, addExceptionMechanism, dateTimestampInSeconds, normalize, truncate, uuid4 } from '@sentry/utils';\n\nimport { DEFAULT_ENVIRONMENT } from '../constants';\nimport { getGlobalEventProcessors, notifyEventProcessors } from '../eventProcessors';\nimport { Scope, getGlobalScope } from '../scope';\nimport { applyScopeDataToEvent, mergeScopeData } from './applyScopeDataToEvent';\nimport { spanToJSON } from './spanUtils';\n\n/**\n * This type makes sure that we get either a CaptureContext, OR an EventHint.\n * It does not allow mixing them, which could lead to unexpected outcomes, e.g. this is disallowed:\n * { user: { id: '123' }, mechanism: { handled: false } }\n */\nexport type ExclusiveEventHintOrCaptureContext =\n  | (CaptureContext & Partial<{ [key in keyof EventHint]: never }>)\n  | (EventHint & Partial<{ [key in keyof ScopeContext]: never }>);\n\n/**\n * Adds common information to events.\n *\n * The information includes release and environment from `options`,\n * breadcrumbs and context (extra, tags and user) from the scope.\n *\n * Information that is already present in the event is never overwritten. For\n * nested objects, such as the context, keys are merged.\n *\n * Note: This also triggers callbacks for `addGlobalEventProcessor`, but not `beforeSend`.\n *\n * @param event The original event.\n * @param hint May contain additional information about the original exception.\n * @param scope A scope containing event metadata.\n * @returns A new event with more information.\n * @hidden\n */\nexport function prepareEvent(\n  options: ClientOptions,\n  event: Event,\n  hint: EventHint,\n  scope?: Scope,\n  client?: Client,\n  isolationScope?: Scope,\n): PromiseLike<Event | null> {\n  const { normalizeDepth = 3, normalizeMaxBreadth = 1_000 } = options;\n  const prepared: Event = {\n    ...event,\n    event_id: event.event_id || hint.event_id || uuid4(),\n    timestamp: event.timestamp || dateTimestampInSeconds(),\n  };\n  const integrations = hint.integrations || options.integrations.map(i => i.name);\n\n  applyClientOptions(prepared, options);\n  applyIntegrationsMetadata(prepared, integrations);\n\n  // Only put debug IDs onto frames for error events.\n  if (event.type === undefined) {\n    applyDebugIds(prepared, options.stackParser);\n  }\n\n  // If we have scope given to us, use it as the base for further modifications.\n  // This allows us to prevent unnecessary copying of data if `captureContext` is not provided.\n  const finalScope = getFinalScope(scope, hint.captureContext);\n\n  if (hint.mechanism) {\n    addExceptionMechanism(prepared, hint.mechanism);\n  }\n\n  const clientEventProcessors = client && client.getEventProcessors ? client.getEventProcessors() : [];\n\n  // This should be the last thing called, since we want that\n  // {@link Hub.addEventProcessor} gets the finished prepared event.\n  // Merge scope data together\n  const data = getGlobalScope().getScopeData();\n\n  if (isolationScope) {\n    const isolationData = isolationScope.getScopeData();\n    mergeScopeData(data, isolationData);\n  }\n\n  if (finalScope) {\n    const finalScopeData = finalScope.getScopeData();\n    mergeScopeData(data, finalScopeData);\n  }\n\n  const attachments = [...(hint.attachments || []), ...data.attachments];\n  if (attachments.length) {\n    hint.attachments = attachments;\n  }\n\n  applyScopeDataToEvent(prepared, data);\n\n  // TODO (v8): Update this order to be: Global > Client > Scope\n  const eventProcessors = [\n    ...clientEventProcessors,\n    // eslint-disable-next-line deprecation/deprecation\n    ...getGlobalEventProcessors(),\n    // Run scope event processors _after_ all other processors\n    ...data.eventProcessors,\n  ];\n\n  const result = notifyEventProcessors(eventProcessors, prepared, hint);\n\n  return result.then(evt => {\n    if (evt) {\n      // We apply the debug_meta field only after all event processors have ran, so that if any event processors modified\n      // file names (e.g.the RewriteFrames integration) the filename -> debug ID relationship isn't destroyed.\n      // This should not cause any PII issues, since we're only moving data that is already on the event and not adding\n      // any new data\n      applyDebugMeta(evt);\n    }\n\n    if (typeof normalizeDepth === 'number' && normalizeDepth > 0) {\n      return normalizeEvent(evt, normalizeDepth, normalizeMaxBreadth);\n    }\n    return evt;\n  });\n}\n\n/**\n *  Enhances event using the client configuration.\n *  It takes care of all \"static\" values like environment, release and `dist`,\n *  as well as truncating overly long values.\n * @param event event instance to be enhanced\n */\nfunction applyClientOptions(event: Event, options: ClientOptions): void {\n  const { environment, release, dist, maxValueLength = 250 } = options;\n\n  if (!('environment' in event)) {\n    event.environment = 'environment' in options ? environment : DEFAULT_ENVIRONMENT;\n  }\n\n  if (event.release === undefined && release !== undefined) {\n    event.release = release;\n  }\n\n  if (event.dist === undefined && dist !== undefined) {\n    event.dist = dist;\n  }\n\n  if (event.message) {\n    event.message = truncate(event.message, maxValueLength);\n  }\n\n  const exception = event.exception && event.exception.values && event.exception.values[0];\n  if (exception && exception.value) {\n    exception.value = truncate(exception.value, maxValueLength);\n  }\n\n  const request = event.request;\n  if (request && request.url) {\n    request.url = truncate(request.url, maxValueLength);\n  }\n}\n\nconst debugIdStackParserCache = new WeakMap<StackParser, Map<string, StackFrame[]>>();\n\n/**\n * Puts debug IDs into the stack frames of an error event.\n */\nexport function applyDebugIds(event: Event, stackParser: StackParser): void {\n  const debugIdMap = GLOBAL_OBJ._sentryDebugIds;\n\n  if (!debugIdMap) {\n    return;\n  }\n\n  let debugIdStackFramesCache: Map<string, StackFrame[]>;\n  const cachedDebugIdStackFrameCache = debugIdStackParserCache.get(stackParser);\n  if (cachedDebugIdStackFrameCache) {\n    debugIdStackFramesCache = cachedDebugIdStackFrameCache;\n  } else {\n    debugIdStackFramesCache = new Map<string, StackFrame[]>();\n    debugIdStackParserCache.set(stackParser, debugIdStackFramesCache);\n  }\n\n  // Build a map of filename -> debug_id\n  const filenameDebugIdMap = Object.keys(debugIdMap).reduce<Record<string, string>>((acc, debugIdStackTrace) => {\n    let parsedStack: StackFrame[];\n    const cachedParsedStack = debugIdStackFramesCache.get(debugIdStackTrace);\n    if (cachedParsedStack) {\n      parsedStack = cachedParsedStack;\n    } else {\n      parsedStack = stackParser(debugIdStackTrace);\n      debugIdStackFramesCache.set(debugIdStackTrace, parsedStack);\n    }\n\n    for (let i = parsedStack.length - 1; i >= 0; i--) {\n      const stackFrame = parsedStack[i];\n      if (stackFrame.filename) {\n        acc[stackFrame.filename] = debugIdMap[debugIdStackTrace];\n        break;\n      }\n    }\n    return acc;\n  }, {});\n\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    event!.exception!.values!.forEach(exception => {\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      exception.stacktrace!.frames!.forEach(frame => {\n        if (frame.filename) {\n          frame.debug_id = filenameDebugIdMap[frame.filename];\n        }\n      });\n    });\n  } catch (e) {\n    // To save bundle size we're just try catching here instead of checking for the existence of all the different objects.\n  }\n}\n\n/**\n * Moves debug IDs from the stack frames of an error event into the debug_meta field.\n */\nexport function applyDebugMeta(event: Event): void {\n  // Extract debug IDs and filenames from the stack frames on the event.\n  const filenameDebugIdMap: Record<string, string> = {};\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    event.exception!.values!.forEach(exception => {\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      exception.stacktrace!.frames!.forEach(frame => {\n        if (frame.debug_id) {\n          if (frame.abs_path) {\n            filenameDebugIdMap[frame.abs_path] = frame.debug_id;\n          } else if (frame.filename) {\n            filenameDebugIdMap[frame.filename] = frame.debug_id;\n          }\n          delete frame.debug_id;\n        }\n      });\n    });\n  } catch (e) {\n    // To save bundle size we're just try catching here instead of checking for the existence of all the different objects.\n  }\n\n  if (Object.keys(filenameDebugIdMap).length === 0) {\n    return;\n  }\n\n  // Fill debug_meta information\n  event.debug_meta = event.debug_meta || {};\n  event.debug_meta.images = event.debug_meta.images || [];\n  const images = event.debug_meta.images;\n  Object.keys(filenameDebugIdMap).forEach(filename => {\n    images.push({\n      type: 'sourcemap',\n      code_file: filename,\n      debug_id: filenameDebugIdMap[filename],\n    });\n  });\n}\n\n/**\n * This function adds all used integrations to the SDK info in the event.\n * @param event The event that will be filled with all integrations.\n */\nfunction applyIntegrationsMetadata(event: Event, integrationNames: string[]): void {\n  if (integrationNames.length > 0) {\n    event.sdk = event.sdk || {};\n    event.sdk.integrations = [...(event.sdk.integrations || []), ...integrationNames];\n  }\n}\n\n/**\n * Applies `normalize` function on necessary `Event` attributes to make them safe for serialization.\n * Normalized keys:\n * - `breadcrumbs.data`\n * - `user`\n * - `contexts`\n * - `extra`\n * @param event Event\n * @returns Normalized event\n */\nfunction normalizeEvent(event: Event | null, depth: number, maxBreadth: number): Event | null {\n  if (!event) {\n    return null;\n  }\n\n  const normalized: Event = {\n    ...event,\n    ...(event.breadcrumbs && {\n      breadcrumbs: event.breadcrumbs.map(b => ({\n        ...b,\n        ...(b.data && {\n          data: normalize(b.data, depth, maxBreadth),\n        }),\n      })),\n    }),\n    ...(event.user && {\n      user: normalize(event.user, depth, maxBreadth),\n    }),\n    ...(event.contexts && {\n      contexts: normalize(event.contexts, depth, maxBreadth),\n    }),\n    ...(event.extra && {\n      extra: normalize(event.extra, depth, maxBreadth),\n    }),\n  };\n\n  // event.contexts.trace stores information about a Transaction. Similarly,\n  // event.spans[] stores information about child Spans. Given that a\n  // Transaction is conceptually a Span, normalization should apply to both\n  // Transactions and Spans consistently.\n  // For now the decision is to skip normalization of Transactions and Spans,\n  // so this block overwrites the normalized event to add back the original\n  // Transaction information prior to normalization.\n  if (event.contexts && event.contexts.trace && normalized.contexts) {\n    normalized.contexts.trace = event.contexts.trace;\n\n    // event.contexts.trace.data may contain circular/dangerous data so we need to normalize it\n    if (event.contexts.trace.data) {\n      normalized.contexts.trace.data = normalize(event.contexts.trace.data, depth, maxBreadth);\n    }\n  }\n\n  // event.spans[].data may contain circular/dangerous data so we need to normalize it\n  if (event.spans) {\n    normalized.spans = event.spans.map(span => {\n      const data = spanToJSON(span).data;\n\n      if (data) {\n        // This is a bit weird, as we generally have `Span` instances here, but to be safe we do not assume so\n        // eslint-disable-next-line deprecation/deprecation\n        span.data = normalize(data, depth, maxBreadth);\n      }\n\n      return span;\n    });\n  }\n\n  return normalized;\n}\n\nfunction getFinalScope(scope: Scope | undefined, captureContext: CaptureContext | undefined): Scope | undefined {\n  if (!captureContext) {\n    return scope;\n  }\n\n  const finalScope = scope ? scope.clone() : new Scope();\n  finalScope.update(captureContext);\n  return finalScope;\n}\n\n/**\n * Parse either an `EventHint` directly, or convert a `CaptureContext` to an `EventHint`.\n * This is used to allow to update method signatures that used to accept a `CaptureContext` but should now accept an `EventHint`.\n */\nexport function parseEventHintOrCaptureContext(\n  hint: ExclusiveEventHintOrCaptureContext | undefined,\n): EventHint | undefined {\n  if (!hint) {\n    return undefined;\n  }\n\n  // If you pass a Scope or `() => Scope` as CaptureContext, we just return this as captureContext\n  if (hintIsScopeOrFunction(hint)) {\n    return { captureContext: hint };\n  }\n\n  if (hintIsScopeContext(hint)) {\n    return {\n      captureContext: hint,\n    };\n  }\n\n  return hint;\n}\n\nfunction hintIsScopeOrFunction(\n  hint: CaptureContext | EventHint,\n): hint is ScopeInterface | ((scope: ScopeInterface) => ScopeInterface) {\n  return hint instanceof Scope || typeof hint === 'function';\n}\n\ntype ScopeContextProperty = keyof ScopeContext;\nconst captureContextKeys: readonly ScopeContextProperty[] = [\n  'user',\n  'level',\n  'extra',\n  'contexts',\n  'tags',\n  'fingerprint',\n  'requestSession',\n  'propagationContext',\n] as const;\n\nfunction hintIsScopeContext(hint: Partial<ScopeContext> | EventHint): hint is Partial<ScopeContext> {\n  return Object.keys(hint).some(key => captureContextKeys.includes(key as ScopeContextProperty));\n}\n","import type { DsnComponents, MetricBucketItem, SdkMetadata, StatsdEnvelope, StatsdItem } from '@sentry/types';\nimport { createEnvelope, dsnToString } from '@sentry/utils';\nimport { serializeMetricBuckets } from './utils';\n\n/**\n * Create envelope from a metric aggregate.\n */\nexport function createMetricEnvelope(\n  metricBucketItems: Array<MetricBucketItem>,\n  dsn?: DsnComponents,\n  metadata?: SdkMetadata,\n  tunnel?: string,\n): StatsdEnvelope {\n  const headers: StatsdEnvelope[0] = {\n    sent_at: new Date().toISOString(),\n  };\n\n  if (metadata && metadata.sdk) {\n    headers.sdk = {\n      name: metadata.sdk.name,\n      version: metadata.sdk.version,\n    };\n  }\n\n  if (!!tunnel && dsn) {\n    headers.dsn = dsnToString(dsn);\n  }\n\n  const item = createMetricEnvelopeItem(metricBucketItems);\n  return createEnvelope<StatsdEnvelope>(headers, [item]);\n}\n\nfunction createMetricEnvelopeItem(metricBucketItems: MetricBucketItem[]): StatsdItem {\n  const payload = serializeMetricBuckets(metricBucketItems);\n  const metricHeaders: StatsdItem[0] = {\n    type: 'statsd',\n    length: payload.length,\n  };\n  return [metricHeaders, payload];\n}\n","/* eslint-disable max-lines */\nimport type {\n  Breadcrumb,\n  BreadcrumbHint,\n  Client,\n  ClientOptions,\n  DataCategory,\n  DsnComponents,\n  DynamicSamplingContext,\n  Envelope,\n  ErrorEvent,\n  Event,\n  EventDropReason,\n  EventHint,\n  EventProcessor,\n  FeedbackEvent,\n  Integration,\n  IntegrationClass,\n  MetricBucketItem,\n  MetricsAggregator,\n  Outcome,\n  ParameterizedString,\n  SdkMetadata,\n  Session,\n  SessionAggregates,\n  Severity,\n  SeverityLevel,\n  StartSpanOptions,\n  Transaction,\n  TransactionEvent,\n  Transport,\n  TransportMakeRequestResponse,\n} from '@sentry/types';\nimport {\n  SentryError,\n  SyncPromise,\n  addItemToEnvelope,\n  checkOrSetAlreadyCaught,\n  createAttachmentEnvelopeItem,\n  isParameterizedString,\n  isPlainObject,\n  isPrimitive,\n  isThenable,\n  logger,\n  makeDsn,\n  rejectedSyncPromise,\n  resolvedSyncPromise,\n} from '@sentry/utils';\n\nimport { getEnvelopeEndpointWithUrlEncodedAuth } from './api';\nimport { DEBUG_BUILD } from './debug-build';\nimport { createEventEnvelope, createSessionEnvelope } from './envelope';\nimport { getClient } from './exports';\nimport { getIsolationScope } from './hub';\nimport type { IntegrationIndex } from './integration';\nimport { afterSetupIntegrations } from './integration';\nimport { setupIntegration, setupIntegrations } from './integration';\nimport { createMetricEnvelope } from './metrics/envelope';\nimport type { Scope } from './scope';\nimport { updateSession } from './session';\nimport { getDynamicSamplingContextFromClient } from './tracing/dynamicSamplingContext';\nimport { prepareEvent } from './utils/prepareEvent';\n\nconst ALREADY_SEEN_ERROR = \"Not capturing exception because it's already been captured.\";\n\n/**\n * Base implementation for all JavaScript SDK clients.\n *\n * Call the constructor with the corresponding options\n * specific to the client subclass. To access these options later, use\n * {@link Client.getOptions}.\n *\n * If a Dsn is specified in the options, it will be parsed and stored. Use\n * {@link Client.getDsn} to retrieve the Dsn at any moment. In case the Dsn is\n * invalid, the constructor will throw a {@link SentryException}. Note that\n * without a valid Dsn, the SDK will not send any events to Sentry.\n *\n * Before sending an event, it is passed through\n * {@link BaseClient._prepareEvent} to add SDK information and scope data\n * (breadcrumbs and context). To add more custom information, override this\n * method and extend the resulting prepared event.\n *\n * To issue automatically created events (e.g. via instrumentation), use\n * {@link Client.captureEvent}. It will prepare the event and pass it through\n * the callback lifecycle. To issue auto-breadcrumbs, use\n * {@link Client.addBreadcrumb}.\n *\n * @example\n * class NodeClient extends BaseClient<NodeOptions> {\n *   public constructor(options: NodeOptions) {\n *     super(options);\n *   }\n *\n *   // ...\n * }\n */\nexport abstract class BaseClient<O extends ClientOptions> implements Client<O> {\n  /**\n   * A reference to a metrics aggregator\n   *\n   * @experimental Note this is alpha API. It may experience breaking changes in the future.\n   */\n  public metricsAggregator?: MetricsAggregator;\n\n  /** Options passed to the SDK. */\n  protected readonly _options: O;\n\n  /** The client Dsn, if specified in options. Without this Dsn, the SDK will be disabled. */\n  protected readonly _dsn?: DsnComponents;\n\n  protected readonly _transport?: Transport;\n\n  /** Array of set up integrations. */\n  protected _integrations: IntegrationIndex;\n\n  /** Indicates whether this client's integrations have been set up. */\n  protected _integrationsInitialized: boolean;\n\n  /** Number of calls being processed */\n  protected _numProcessing: number;\n\n  protected _eventProcessors: EventProcessor[];\n\n  /** Holds flushable  */\n  private _outcomes: { [key: string]: number };\n\n  // eslint-disable-next-line @typescript-eslint/ban-types\n  private _hooks: Record<string, Function[]>;\n\n  /**\n   * Initializes this client instance.\n   *\n   * @param options Options for the client.\n   */\n  protected constructor(options: O) {\n    this._options = options;\n    this._integrations = {};\n    this._integrationsInitialized = false;\n    this._numProcessing = 0;\n    this._outcomes = {};\n    this._hooks = {};\n    this._eventProcessors = [];\n\n    if (options.dsn) {\n      this._dsn = makeDsn(options.dsn);\n    } else {\n      DEBUG_BUILD && logger.warn('No DSN provided, client will not send events.');\n    }\n\n    if (this._dsn) {\n      const url = getEnvelopeEndpointWithUrlEncodedAuth(this._dsn, options);\n      this._transport = options.transport({\n        tunnel: this._options.tunnel,\n        recordDroppedEvent: this.recordDroppedEvent.bind(this),\n        ...options.transportOptions,\n        url,\n      });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n  public captureException(exception: any, hint?: EventHint, scope?: Scope): string | undefined {\n    // ensure we haven't captured this very object before\n    if (checkOrSetAlreadyCaught(exception)) {\n      DEBUG_BUILD && logger.log(ALREADY_SEEN_ERROR);\n      return;\n    }\n\n    let eventId: string | undefined = hint && hint.event_id;\n\n    this._process(\n      this.eventFromException(exception, hint)\n        .then(event => this._captureEvent(event, hint, scope))\n        .then(result => {\n          eventId = result;\n        }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureMessage(\n    message: ParameterizedString,\n    // eslint-disable-next-line deprecation/deprecation\n    level?: Severity | SeverityLevel,\n    hint?: EventHint,\n    scope?: Scope,\n  ): string | undefined {\n    let eventId: string | undefined = hint && hint.event_id;\n\n    const eventMessage = isParameterizedString(message) ? message : String(message);\n\n    const promisedEvent = isPrimitive(message)\n      ? this.eventFromMessage(eventMessage, level, hint)\n      : this.eventFromException(message, hint);\n\n    this._process(\n      promisedEvent\n        .then(event => this._captureEvent(event, hint, scope))\n        .then(result => {\n          eventId = result;\n        }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureEvent(event: Event, hint?: EventHint, scope?: Scope): string | undefined {\n    // ensure we haven't captured this very object before\n    if (hint && hint.originalException && checkOrSetAlreadyCaught(hint.originalException)) {\n      DEBUG_BUILD && logger.log(ALREADY_SEEN_ERROR);\n      return;\n    }\n\n    let eventId: string | undefined = hint && hint.event_id;\n\n    const sdkProcessingMetadata = event.sdkProcessingMetadata || {};\n    const capturedSpanScope: Scope | undefined = sdkProcessingMetadata.capturedSpanScope;\n\n    this._process(\n      this._captureEvent(event, hint, capturedSpanScope || scope).then(result => {\n        eventId = result;\n      }),\n    );\n\n    return eventId;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureSession(session: Session): void {\n    if (!(typeof session.release === 'string')) {\n      DEBUG_BUILD && logger.warn('Discarded session because of missing or non-string release');\n    } else {\n      this.sendSession(session);\n      // After sending, we set init false to indicate it's not the first occurrence\n      updateSession(session, { init: false });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getDsn(): DsnComponents | undefined {\n    return this._dsn;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getOptions(): O {\n    return this._options;\n  }\n\n  /**\n   * @see SdkMetadata in @sentry/types\n   *\n   * @return The metadata of the SDK\n   */\n  public getSdkMetadata(): SdkMetadata | undefined {\n    return this._options._metadata;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public getTransport(): Transport | undefined {\n    return this._transport;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public flush(timeout?: number): PromiseLike<boolean> {\n    const transport = this._transport;\n    if (transport) {\n      if (this.metricsAggregator) {\n        this.metricsAggregator.flush();\n      }\n      return this._isClientDoneProcessing(timeout).then(clientFinished => {\n        return transport.flush(timeout).then(transportFlushed => clientFinished && transportFlushed);\n      });\n    } else {\n      return resolvedSyncPromise(true);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public close(timeout?: number): PromiseLike<boolean> {\n    return this.flush(timeout).then(result => {\n      this.getOptions().enabled = false;\n      if (this.metricsAggregator) {\n        this.metricsAggregator.close();\n      }\n      return result;\n    });\n  }\n\n  /** Get all installed event processors. */\n  public getEventProcessors(): EventProcessor[] {\n    return this._eventProcessors;\n  }\n\n  /** @inheritDoc */\n  public addEventProcessor(eventProcessor: EventProcessor): void {\n    this._eventProcessors.push(eventProcessor);\n  }\n\n  /**\n   * This is an internal function to setup all integrations that should run on the client.\n   * @deprecated Use `client.init()` instead.\n   */\n  public setupIntegrations(forceInitialize?: boolean): void {\n    if ((forceInitialize && !this._integrationsInitialized) || (this._isEnabled() && !this._integrationsInitialized)) {\n      this._setupIntegrations();\n    }\n  }\n\n  /** @inheritdoc */\n  public init(): void {\n    if (this._isEnabled()) {\n      this._setupIntegrations();\n    }\n  }\n\n  /**\n   * Gets an installed integration by its `id`.\n   *\n   * @returns The installed integration or `undefined` if no integration with that `id` was installed.\n   * @deprecated Use `getIntegrationByName()` instead.\n   */\n  public getIntegrationById(integrationId: string): Integration | undefined {\n    return this.getIntegrationByName(integrationId);\n  }\n\n  /**\n   * Gets an installed integration by its name.\n   *\n   * @returns The installed integration or `undefined` if no integration with that `name` was installed.\n   */\n  public getIntegrationByName<T extends Integration = Integration>(integrationName: string): T | undefined {\n    return this._integrations[integrationName] as T | undefined;\n  }\n\n  /**\n   * Returns the client's instance of the given integration class, it any.\n   * @deprecated Use `getIntegrationByName()` instead.\n   */\n  public getIntegration<T extends Integration>(integration: IntegrationClass<T>): T | null {\n    try {\n      return (this._integrations[integration.id] as T) || null;\n    } catch (_oO) {\n      DEBUG_BUILD && logger.warn(`Cannot retrieve integration ${integration.id} from the current Client`);\n      return null;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public addIntegration(integration: Integration): void {\n    const isAlreadyInstalled = this._integrations[integration.name];\n\n    // This hook takes care of only installing if not already installed\n    setupIntegration(this, integration, this._integrations);\n    // Here we need to check manually to make sure to not run this multiple times\n    if (!isAlreadyInstalled) {\n      afterSetupIntegrations(this, [integration]);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public sendEvent(event: Event, hint: EventHint = {}): void {\n    this.emit('beforeSendEvent', event, hint);\n\n    let env = createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);\n\n    for (const attachment of hint.attachments || []) {\n      env = addItemToEnvelope(\n        env,\n        createAttachmentEnvelopeItem(\n          attachment,\n          this._options.transportOptions && this._options.transportOptions.textEncoder,\n        ),\n      );\n    }\n\n    const promise = this._sendEnvelope(env);\n    if (promise) {\n      promise.then(sendResponse => this.emit('afterSendEvent', event, sendResponse), null);\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public sendSession(session: Session | SessionAggregates): void {\n    const env = createSessionEnvelope(session, this._dsn, this._options._metadata, this._options.tunnel);\n\n    // _sendEnvelope should not throw\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this._sendEnvelope(env);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public recordDroppedEvent(reason: EventDropReason, category: DataCategory, eventOrCount?: Event | number): void {\n    if (this._options.sendClientReports) {\n      // TODO v9: We do not need the `event` passed as third argument anymore, and can possibly remove this overload\n      // If event is passed as third argument, we assume this is a count of 1\n      const count = typeof eventOrCount === 'number' ? eventOrCount : 1;\n\n      // We want to track each category (error, transaction, session, replay_event) separately\n      // but still keep the distinction between different type of outcomes.\n      // We could use nested maps, but it's much easier to read and type this way.\n      // A correct type for map-based implementation if we want to go that route\n      // would be `Partial<Record<SentryRequestType, Partial<Record<Outcome, number>>>>`\n      // With typescript 4.1 we could even use template literal types\n      const key = `${reason}:${category}`;\n      DEBUG_BUILD && logger.log(`Recording outcome: \"${key}\"${count > 1 ? ` (${count} times)` : ''}`);\n      this._outcomes[key] = (this._outcomes[key] || 0) + count;\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public captureAggregateMetrics(metricBucketItems: Array<MetricBucketItem>): void {\n    DEBUG_BUILD && logger.log(`Flushing aggregated metrics, number of metrics: ${metricBucketItems.length}`);\n    const metricsEnvelope = createMetricEnvelope(\n      metricBucketItems,\n      this._dsn,\n      this._options._metadata,\n      this._options.tunnel,\n    );\n\n    // _sendEnvelope should not throw\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this._sendEnvelope(metricsEnvelope);\n  }\n\n  // Keep on() & emit() signatures in sync with types' client.ts interface\n  /* eslint-disable @typescript-eslint/unified-signatures */\n\n  /** @inheritdoc */\n  public on(hook: 'startTransaction', callback: (transaction: Transaction) => void): void;\n\n  /** @inheritdoc */\n  public on(hook: 'finishTransaction', callback: (transaction: Transaction) => void): void;\n\n  /** @inheritdoc */\n  public on(hook: 'beforeEnvelope', callback: (envelope: Envelope) => void): void;\n\n  /** @inheritdoc */\n  public on(hook: 'beforeSendEvent', callback: (event: Event, hint?: EventHint) => void): void;\n\n  /** @inheritdoc */\n  public on(hook: 'preprocessEvent', callback: (event: Event, hint?: EventHint) => void): void;\n\n  /** @inheritdoc */\n  public on(\n    hook: 'afterSendEvent',\n    callback: (event: Event, sendResponse: TransportMakeRequestResponse | void) => void,\n  ): void;\n\n  /** @inheritdoc */\n  public on(hook: 'beforeAddBreadcrumb', callback: (breadcrumb: Breadcrumb, hint?: BreadcrumbHint) => void): void;\n\n  /** @inheritdoc */\n  public on(hook: 'createDsc', callback: (dsc: DynamicSamplingContext) => void): void;\n\n  /** @inheritdoc */\n  public on(hook: 'otelSpanEnd', callback: (otelSpan: unknown, mutableOptions: { drop: boolean }) => void): void;\n\n  /** @inheritdoc */\n  public on(\n    hook: 'beforeSendFeedback',\n    callback: (feedback: FeedbackEvent, options?: { includeReplay: boolean }) => void,\n  ): void;\n\n  /** @inheritdoc */\n  public on(hook: 'startPageLoadSpan', callback: (options: StartSpanOptions) => void): void;\n\n  /** @inheritdoc */\n  public on(hook: 'startNavigationSpan', callback: (options: StartSpanOptions) => void): void;\n\n  /** @inheritdoc */\n  public on(hook: string, callback: unknown): void {\n    if (!this._hooks[hook]) {\n      this._hooks[hook] = [];\n    }\n\n    // @ts-expect-error We assue the types are correct\n    this._hooks[hook].push(callback);\n  }\n\n  /** @inheritdoc */\n  public emit(hook: 'startTransaction', transaction: Transaction): void;\n\n  /** @inheritdoc */\n  public emit(hook: 'finishTransaction', transaction: Transaction): void;\n\n  /** @inheritdoc */\n  public emit(hook: 'beforeEnvelope', envelope: Envelope): void;\n\n  /** @inheritdoc */\n  public emit(hook: 'beforeSendEvent', event: Event, hint?: EventHint): void;\n\n  /** @inheritdoc */\n  public emit(hook: 'preprocessEvent', event: Event, hint?: EventHint): void;\n\n  /** @inheritdoc */\n  public emit(hook: 'afterSendEvent', event: Event, sendResponse: TransportMakeRequestResponse | void): void;\n\n  /** @inheritdoc */\n  public emit(hook: 'beforeAddBreadcrumb', breadcrumb: Breadcrumb, hint?: BreadcrumbHint): void;\n\n  /** @inheritdoc */\n  public emit(hook: 'createDsc', dsc: DynamicSamplingContext): void;\n\n  /** @inheritdoc */\n  public emit(hook: 'otelSpanEnd', otelSpan: unknown, mutableOptions: { drop: boolean }): void;\n\n  /** @inheritdoc */\n  public emit(hook: 'beforeSendFeedback', feedback: FeedbackEvent, options?: { includeReplay: boolean }): void;\n\n  /** @inheritdoc */\n  public emit(hook: 'startPageLoadSpan', options: StartSpanOptions): void;\n\n  /** @inheritdoc */\n  public emit(hook: 'startNavigationSpan', options: StartSpanOptions): void;\n\n  /** @inheritdoc */\n  public emit(hook: string, ...rest: unknown[]): void {\n    if (this._hooks[hook]) {\n      this._hooks[hook].forEach(callback => callback(...rest));\n    }\n  }\n\n  /* eslint-enable @typescript-eslint/unified-signatures */\n\n  /** Setup integrations for this client. */\n  protected _setupIntegrations(): void {\n    const { integrations } = this._options;\n    this._integrations = setupIntegrations(this, integrations);\n    afterSetupIntegrations(this, integrations);\n\n    // TODO v8: We don't need this flag anymore\n    this._integrationsInitialized = true;\n  }\n\n  /** Updates existing session based on the provided event */\n  protected _updateSessionFromEvent(session: Session, event: Event): void {\n    let crashed = false;\n    let errored = false;\n    const exceptions = event.exception && event.exception.values;\n\n    if (exceptions) {\n      errored = true;\n\n      for (const ex of exceptions) {\n        const mechanism = ex.mechanism;\n        if (mechanism && mechanism.handled === false) {\n          crashed = true;\n          break;\n        }\n      }\n    }\n\n    // A session is updated and that session update is sent in only one of the two following scenarios:\n    // 1. Session with non terminal status and 0 errors + an error occurred -> Will set error count to 1 and send update\n    // 2. Session with non terminal status and 1 error + a crash occurred -> Will set status crashed and send update\n    const sessionNonTerminal = session.status === 'ok';\n    const shouldUpdateAndSend = (sessionNonTerminal && session.errors === 0) || (sessionNonTerminal && crashed);\n\n    if (shouldUpdateAndSend) {\n      updateSession(session, {\n        ...(crashed && { status: 'crashed' }),\n        errors: session.errors || Number(errored || crashed),\n      });\n      this.captureSession(session);\n    }\n  }\n\n  /**\n   * Determine if the client is finished processing. Returns a promise because it will wait `timeout` ms before saying\n   * \"no\" (resolving to `false`) in order to give the client a chance to potentially finish first.\n   *\n   * @param timeout The time, in ms, after which to resolve to `false` if the client is still busy. Passing `0` (or not\n   * passing anything) will make the promise wait as long as it takes for processing to finish before resolving to\n   * `true`.\n   * @returns A promise which will resolve to `true` if processing is already done or finishes before the timeout, and\n   * `false` otherwise\n   */\n  protected _isClientDoneProcessing(timeout?: number): PromiseLike<boolean> {\n    return new SyncPromise(resolve => {\n      let ticked: number = 0;\n      const tick: number = 1;\n\n      const interval = setInterval(() => {\n        if (this._numProcessing == 0) {\n          clearInterval(interval);\n          resolve(true);\n        } else {\n          ticked += tick;\n          if (timeout && ticked >= timeout) {\n            clearInterval(interval);\n            resolve(false);\n          }\n        }\n      }, tick);\n    });\n  }\n\n  /** Determines whether this SDK is enabled and a transport is present. */\n  protected _isEnabled(): boolean {\n    return this.getOptions().enabled !== false && this._transport !== undefined;\n  }\n\n  /**\n   * Adds common information to events.\n   *\n   * The information includes release and environment from `options`,\n   * breadcrumbs and context (extra, tags and user) from the scope.\n   *\n   * Information that is already present in the event is never overwritten. For\n   * nested objects, such as the context, keys are merged.\n   *\n   * @param event The original event.\n   * @param hint May contain additional information about the original exception.\n   * @param scope A scope containing event metadata.\n   * @returns A new event with more information.\n   */\n  protected _prepareEvent(\n    event: Event,\n    hint: EventHint,\n    scope?: Scope,\n    isolationScope = getIsolationScope(),\n  ): PromiseLike<Event | null> {\n    const options = this.getOptions();\n    const integrations = Object.keys(this._integrations);\n    if (!hint.integrations && integrations.length > 0) {\n      hint.integrations = integrations;\n    }\n\n    this.emit('preprocessEvent', event, hint);\n\n    return prepareEvent(options, event, hint, scope, this, isolationScope).then(evt => {\n      if (evt === null) {\n        return evt;\n      }\n\n      const propagationContext = {\n        ...isolationScope.getPropagationContext(),\n        ...(scope ? scope.getPropagationContext() : undefined),\n      };\n\n      const trace = evt.contexts && evt.contexts.trace;\n      if (!trace && propagationContext) {\n        const { traceId: trace_id, spanId, parentSpanId, dsc } = propagationContext;\n        evt.contexts = {\n          trace: {\n            trace_id,\n            span_id: spanId,\n            parent_span_id: parentSpanId,\n          },\n          ...evt.contexts,\n        };\n\n        const dynamicSamplingContext = dsc ? dsc : getDynamicSamplingContextFromClient(trace_id, this, scope);\n\n        evt.sdkProcessingMetadata = {\n          dynamicSamplingContext,\n          ...evt.sdkProcessingMetadata,\n        };\n      }\n      return evt;\n    });\n  }\n\n  /**\n   * Processes the event and logs an error in case of rejection\n   * @param event\n   * @param hint\n   * @param scope\n   */\n  protected _captureEvent(event: Event, hint: EventHint = {}, scope?: Scope): PromiseLike<string | undefined> {\n    return this._processEvent(event, hint, scope).then(\n      finalEvent => {\n        return finalEvent.event_id;\n      },\n      reason => {\n        if (DEBUG_BUILD) {\n          // If something's gone wrong, log the error as a warning. If it's just us having used a `SentryError` for\n          // control flow, log just the message (no stack) as a log-level log.\n          const sentryError = reason as SentryError;\n          if (sentryError.logLevel === 'log') {\n            logger.log(sentryError.message);\n          } else {\n            logger.warn(sentryError);\n          }\n        }\n        return undefined;\n      },\n    );\n  }\n\n  /**\n   * Processes an event (either error or message) and sends it to Sentry.\n   *\n   * This also adds breadcrumbs and context information to the event. However,\n   * platform specific meta data (such as the User's IP address) must be added\n   * by the SDK implementor.\n   *\n   *\n   * @param event The event to send to Sentry.\n   * @param hint May contain additional information about the original exception.\n   * @param scope A scope containing event metadata.\n   * @returns A SyncPromise that resolves with the event or rejects in case event was/will not be send.\n   */\n  protected _processEvent(event: Event, hint: EventHint, scope?: Scope): PromiseLike<Event> {\n    const options = this.getOptions();\n    const { sampleRate } = options;\n\n    const isTransaction = isTransactionEvent(event);\n    const isError = isErrorEvent(event);\n    const eventType = event.type || 'error';\n    const beforeSendLabel = `before send for type \\`${eventType}\\``;\n\n    // 1.0 === 100% events are sent\n    // 0.0 === 0% events are sent\n    // Sampling for transaction happens somewhere else\n    if (isError && typeof sampleRate === 'number' && Math.random() > sampleRate) {\n      this.recordDroppedEvent('sample_rate', 'error', event);\n      return rejectedSyncPromise(\n        new SentryError(\n          `Discarding event because it's not included in the random sample (sampling rate = ${sampleRate})`,\n          'log',\n        ),\n      );\n    }\n\n    const dataCategory: DataCategory = eventType === 'replay_event' ? 'replay' : eventType;\n\n    const sdkProcessingMetadata = event.sdkProcessingMetadata || {};\n    const capturedSpanIsolationScope: Scope | undefined = sdkProcessingMetadata.capturedSpanIsolationScope;\n\n    return this._prepareEvent(event, hint, scope, capturedSpanIsolationScope)\n      .then(prepared => {\n        if (prepared === null) {\n          this.recordDroppedEvent('event_processor', dataCategory, event);\n          throw new SentryError('An event processor returned `null`, will not send event.', 'log');\n        }\n\n        const isInternalException = hint.data && (hint.data as { __sentry__: boolean }).__sentry__ === true;\n        if (isInternalException) {\n          return prepared;\n        }\n\n        const result = processBeforeSend(options, prepared, hint);\n        return _validateBeforeSendResult(result, beforeSendLabel);\n      })\n      .then(processedEvent => {\n        if (processedEvent === null) {\n          this.recordDroppedEvent('before_send', dataCategory, event);\n          if (isTransaction) {\n            const spans = event.spans || [];\n            // the transaction itself counts as one span, plus all the child spans that are added\n            const spanCount = 1 + spans.length;\n            this.recordDroppedEvent('before_send', 'span', spanCount);\n          }\n          throw new SentryError(`${beforeSendLabel} returned \\`null\\`, will not send event.`, 'log');\n        }\n\n        const session = scope && scope.getSession();\n        if (!isTransaction && session) {\n          this._updateSessionFromEvent(session, processedEvent);\n        }\n\n        if (isTransaction) {\n          const spanCountBefore =\n            (processedEvent.sdkProcessingMetadata && processedEvent.sdkProcessingMetadata.spanCountBeforeProcessing) ||\n            0;\n          const spanCountAfter = processedEvent.spans ? processedEvent.spans.length : 0;\n\n          const droppedSpanCount = spanCountBefore - spanCountAfter;\n          if (droppedSpanCount > 0) {\n            this.recordDroppedEvent('before_send', 'span', droppedSpanCount);\n          }\n        }\n\n        // None of the Sentry built event processor will update transaction name,\n        // so if the transaction name has been changed by an event processor, we know\n        // it has to come from custom event processor added by a user\n        const transactionInfo = processedEvent.transaction_info;\n        if (isTransaction && transactionInfo && processedEvent.transaction !== event.transaction) {\n          const source = 'custom';\n          processedEvent.transaction_info = {\n            ...transactionInfo,\n            source,\n          };\n        }\n\n        this.sendEvent(processedEvent, hint);\n        return processedEvent;\n      })\n      .then(null, reason => {\n        if (reason instanceof SentryError) {\n          throw reason;\n        }\n\n        this.captureException(reason, {\n          data: {\n            __sentry__: true,\n          },\n          originalException: reason,\n        });\n        throw new SentryError(\n          `Event processing pipeline threw an error, original event will not be sent. Details have been sent as a new event.\\nReason: ${reason}`,\n        );\n      });\n  }\n\n  /**\n   * Occupies the client with processing and event\n   */\n  protected _process<T>(promise: PromiseLike<T>): void {\n    this._numProcessing++;\n    void promise.then(\n      value => {\n        this._numProcessing--;\n        return value;\n      },\n      reason => {\n        this._numProcessing--;\n        return reason;\n      },\n    );\n  }\n\n  /**\n   * @inheritdoc\n   */\n  protected _sendEnvelope(envelope: Envelope): PromiseLike<void | TransportMakeRequestResponse> | void {\n    this.emit('beforeEnvelope', envelope);\n\n    if (this._isEnabled() && this._transport) {\n      return this._transport.send(envelope).then(null, reason => {\n        DEBUG_BUILD && logger.error('Error while sending event:', reason);\n      });\n    } else {\n      DEBUG_BUILD && logger.error('Transport disabled');\n    }\n  }\n\n  /**\n   * Clears outcomes on this client and returns them.\n   */\n  protected _clearOutcomes(): Outcome[] {\n    const outcomes = this._outcomes;\n    this._outcomes = {};\n    return Object.keys(outcomes).map(key => {\n      const [reason, category] = key.split(':') as [EventDropReason, DataCategory];\n      return {\n        reason,\n        category,\n        quantity: outcomes[key],\n      };\n    });\n  }\n\n  /**\n   * @inheritDoc\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types\n  public abstract eventFromException(_exception: any, _hint?: EventHint): PromiseLike<Event>;\n\n  /**\n   * @inheritDoc\n   */\n  public abstract eventFromMessage(\n    _message: ParameterizedString,\n    // eslint-disable-next-line deprecation/deprecation\n    _level?: Severity | SeverityLevel,\n    _hint?: EventHint,\n  ): PromiseLike<Event>;\n}\n\n/**\n * Verifies that return value of configured `beforeSend` or `beforeSendTransaction` is of expected type, and returns the value if so.\n */\nfunction _validateBeforeSendResult(\n  beforeSendResult: PromiseLike<Event | null> | Event | null,\n  beforeSendLabel: string,\n): PromiseLike<Event | null> | Event | null {\n  const invalidValueError = `${beforeSendLabel} must return \\`null\\` or a valid event.`;\n  if (isThenable(beforeSendResult)) {\n    return beforeSendResult.then(\n      event => {\n        if (!isPlainObject(event) && event !== null) {\n          throw new SentryError(invalidValueError);\n        }\n        return event;\n      },\n      e => {\n        throw new SentryError(`${beforeSendLabel} rejected with ${e}`);\n      },\n    );\n  } else if (!isPlainObject(beforeSendResult) && beforeSendResult !== null) {\n    throw new SentryError(invalidValueError);\n  }\n  return beforeSendResult;\n}\n\n/**\n * Process the matching `beforeSendXXX` callback.\n */\nfunction processBeforeSend(\n  options: ClientOptions,\n  event: Event,\n  hint: EventHint,\n): PromiseLike<Event | null> | Event | null {\n  const { beforeSend, beforeSendTransaction } = options;\n\n  if (isErrorEvent(event) && beforeSend) {\n    return beforeSend(event, hint);\n  }\n\n  if (isTransactionEvent(event) && beforeSendTransaction) {\n    if (event.spans) {\n      // We store the # of spans before processing in SDK metadata,\n      // so we can compare it afterwards to determine how many spans were dropped\n      const spanCountBefore = event.spans.length;\n      event.sdkProcessingMetadata = {\n        ...event.sdkProcessingMetadata,\n        spanCountBeforeProcessing: spanCountBefore,\n      };\n    }\n    return beforeSendTransaction(event, hint);\n  }\n\n  return event;\n}\n\nfunction isErrorEvent(event: Event): event is ErrorEvent {\n  return event.type === undefined;\n}\n\nfunction isTransactionEvent(event: Event): event is TransactionEvent {\n  return event.type === 'transaction';\n}\n\n/**\n * Add an event processor to the current client.\n * This event processor will run for all events processed by this client.\n */\nexport function addEventProcessor(callback: EventProcessor): void {\n  const client = getClient();\n\n  if (!client || !client.addEventProcessor) {\n    return;\n  }\n\n  client.addEventProcessor(callback);\n}\n","import { isString } from './is';\nimport { getGlobalObject } from './worldwide';\n\n// eslint-disable-next-line deprecation/deprecation\nconst WINDOW = getGlobalObject<Window>();\n\nconst DEFAULT_MAX_STRING_LENGTH = 80;\n\ntype SimpleNode = {\n  parentNode: SimpleNode;\n} | null;\n\n/**\n * Given a child DOM element, returns a query-selector statement describing that\n * and its ancestors\n * e.g. [HTMLElement] => body > div > input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nexport function htmlTreeAsString(\n  elem: unknown,\n  options: string[] | { keyAttrs?: string[]; maxStringLength?: number } = {},\n): string {\n  if (!elem) {\n    return '<unknown>';\n  }\n\n  // try/catch both:\n  // - accessing event.target (see getsentry/raven-js#838, #768)\n  // - `htmlTreeAsString` because it's complex, and just accessing the DOM incorrectly\n  // - can throw an exception in some circumstances.\n  try {\n    let currentElem = elem as SimpleNode;\n    const MAX_TRAVERSE_HEIGHT = 5;\n    const out = [];\n    let height = 0;\n    let len = 0;\n    const separator = ' > ';\n    const sepLength = separator.length;\n    let nextStr;\n    const keyAttrs = Array.isArray(options) ? options : options.keyAttrs;\n    const maxStringLength = (!Array.isArray(options) && options.maxStringLength) || DEFAULT_MAX_STRING_LENGTH;\n\n    while (currentElem && height++ < MAX_TRAVERSE_HEIGHT) {\n      nextStr = _htmlElementAsString(currentElem, keyAttrs);\n      // bail out if\n      // - nextStr is the 'html' element\n      // - the length of the string that would be created exceeds maxStringLength\n      //   (ignore this limit if we are on the first iteration)\n      if (nextStr === 'html' || (height > 1 && len + out.length * sepLength + nextStr.length >= maxStringLength)) {\n        break;\n      }\n\n      out.push(nextStr);\n\n      len += nextStr.length;\n      currentElem = currentElem.parentNode;\n    }\n\n    return out.reverse().join(separator);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/**\n * Returns a simple, query-selector representation of a DOM element\n * e.g. [HTMLElement] => input#foo.btn[name=baz]\n * @returns generated DOM path\n */\nfunction _htmlElementAsString(el: unknown, keyAttrs?: string[]): string {\n  const elem = el as {\n    tagName?: string;\n    id?: string;\n    className?: string;\n    getAttribute(key: string): string;\n  };\n\n  const out = [];\n  let className;\n  let classes;\n  let key;\n  let attr;\n  let i;\n\n  if (!elem || !elem.tagName) {\n    return '';\n  }\n\n  // @ts-expect-error WINDOW has HTMLElement\n  if (WINDOW.HTMLElement) {\n    // If using the component name annotation plugin, this value may be available on the DOM node\n    if (elem instanceof HTMLElement && elem.dataset && elem.dataset['sentryComponent']) {\n      return elem.dataset['sentryComponent'];\n    }\n  }\n\n  out.push(elem.tagName.toLowerCase());\n\n  // Pairs of attribute keys defined in `serializeAttribute` and their values on element.\n  const keyAttrPairs =\n    keyAttrs && keyAttrs.length\n      ? keyAttrs.filter(keyAttr => elem.getAttribute(keyAttr)).map(keyAttr => [keyAttr, elem.getAttribute(keyAttr)])\n      : null;\n\n  if (keyAttrPairs && keyAttrPairs.length) {\n    keyAttrPairs.forEach(keyAttrPair => {\n      out.push(`[${keyAttrPair[0]}=\"${keyAttrPair[1]}\"]`);\n    });\n  } else {\n    if (elem.id) {\n      out.push(`#${elem.id}`);\n    }\n\n    // eslint-disable-next-line prefer-const\n    className = elem.className;\n    if (className && isString(className)) {\n      classes = className.split(/\\s+/);\n      for (i = 0; i < classes.length; i++) {\n        out.push(`.${classes[i]}`);\n      }\n    }\n  }\n  const allowedAttrs = ['aria-label', 'type', 'name', 'title', 'alt'];\n  for (i = 0; i < allowedAttrs.length; i++) {\n    key = allowedAttrs[i];\n    attr = elem.getAttribute(key);\n    if (attr) {\n      out.push(`[${key}=\"${attr}\"]`);\n    }\n  }\n  return out.join('');\n}\n\n/**\n * A safe form of location.href\n */\nexport function getLocationHref(): string {\n  try {\n    return WINDOW.document.location.href;\n  } catch (oO) {\n    return '';\n  }\n}\n\n/**\n * Gets a DOM element by using document.querySelector.\n *\n * This wrapper will first check for the existance of the function before\n * actually calling it so that we don't have to take care of this check,\n * every time we want to access the DOM.\n *\n * Reason: DOM/querySelector is not available in all environments.\n *\n * We have to cast to any because utils can be consumed by a variety of environments,\n * and we don't want to break TS users. If you know what element will be selected by\n * `document.querySelector`, specify it as part of the generic call. For example,\n * `const element = getDomElement<Element>('selector');`\n *\n * @param selector the selector string passed on to document.querySelector\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function getDomElement<E = any>(selector: string): E | null {\n  if (WINDOW.document && WINDOW.document.querySelector) {\n    return WINDOW.document.querySelector(selector) as unknown as E;\n  }\n  return null;\n}\n\n/**\n * Given a DOM element, traverses up the tree until it finds the first ancestor node\n * that has the `data-sentry-component` attribute. This attribute is added at build-time\n * by projects that have the component name annotation plugin installed.\n *\n * @returns a string representation of the component for the provided DOM element, or `null` if not found\n */\nexport function getComponentName(elem: unknown): string | null {\n  // @ts-expect-error WINDOW has HTMLElement\n  if (!WINDOW.HTMLElement) {\n    return null;\n  }\n\n  let currentElem = elem as SimpleNode;\n  const MAX_TRAVERSE_HEIGHT = 5;\n  for (let i = 0; i < MAX_TRAVERSE_HEIGHT; i++) {\n    if (!currentElem) {\n      return null;\n    }\n\n    if (currentElem instanceof HTMLElement && currentElem.dataset['sentryComponent']) {\n      return currentElem.dataset['sentryComponent'];\n    }\n\n    currentElem = currentElem.parentNode;\n  }\n\n  return null;\n}\n","/* eslint-disable max-lines */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { WrappedFunction } from '@sentry/types';\n\nimport { htmlTreeAsString } from './browser';\nimport { DEBUG_BUILD } from './debug-build';\nimport { isElement, isError, isEvent, isInstanceOf, isPlainObject, isPrimitive } from './is';\nimport { logger } from './logger';\nimport { truncate } from './string';\n\n/**\n * Replace a method in an object with a wrapped version of itself.\n *\n * @param source An object that contains a method to be wrapped.\n * @param name The name of the method to be wrapped.\n * @param replacementFactory A higher-order function that takes the original version of the given method and returns a\n * wrapped version. Note: The function returned by `replacementFactory` needs to be a non-arrow function, in order to\n * preserve the correct value of `this`, and the original method must be called using `origMethod.call(this, <other\n * args>)` or `origMethod.apply(this, [<other args>])` (rather than being called directly), again to preserve `this`.\n * @returns void\n */\nexport function fill(source: { [key: string]: any }, name: string, replacementFactory: (...args: any[]) => any): void {\n  if (!(name in source)) {\n    return;\n  }\n\n  const original = source[name] as () => any;\n  const wrapped = replacementFactory(original) as WrappedFunction;\n\n  // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work\n  // otherwise it'll throw \"TypeError: Object.defineProperties called on non-object\"\n  if (typeof wrapped === 'function') {\n    markFunctionWrapped(wrapped, original);\n  }\n\n  source[name] = wrapped;\n}\n\n/**\n * Defines a non-enumerable property on the given object.\n *\n * @param obj The object on which to set the property\n * @param name The name of the property to be set\n * @param value The value to which to set the property\n */\nexport function addNonEnumerableProperty(obj: object, name: string, value: unknown): void {\n  try {\n    Object.defineProperty(obj, name, {\n      // enumerable: false, // the default, so we can save on bundle size by not explicitly setting it\n      value: value,\n      writable: true,\n      configurable: true,\n    });\n  } catch (o_O) {\n    DEBUG_BUILD && logger.log(`Failed to add non-enumerable property \"${name}\" to object`, obj);\n  }\n}\n\n/**\n * Remembers the original function on the wrapped function and\n * patches up the prototype.\n *\n * @param wrapped the wrapper function\n * @param original the original function that gets wrapped\n */\nexport function markFunctionWrapped(wrapped: WrappedFunction, original: WrappedFunction): void {\n  try {\n    const proto = original.prototype || {};\n    wrapped.prototype = original.prototype = proto;\n    addNonEnumerableProperty(wrapped, '__sentry_original__', original);\n  } catch (o_O) {} // eslint-disable-line no-empty\n}\n\n/**\n * This extracts the original function if available.  See\n * `markFunctionWrapped` for more information.\n *\n * @param func the function to unwrap\n * @returns the unwrapped version of the function if available.\n */\nexport function getOriginalFunction(func: WrappedFunction): WrappedFunction | undefined {\n  return func.__sentry_original__;\n}\n\n/**\n * Encodes given object into url-friendly format\n *\n * @param object An object that contains serializable values\n * @returns string Encoded\n */\nexport function urlEncode(object: { [key: string]: any }): string {\n  return Object.keys(object)\n    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(object[key])}`)\n    .join('&');\n}\n\n/**\n * Transforms any `Error` or `Event` into a plain object with all of their enumerable properties, and some of their\n * non-enumerable properties attached.\n *\n * @param value Initial source that we have to transform in order for it to be usable by the serializer\n * @returns An Event or Error turned into an object - or the value argurment itself, when value is neither an Event nor\n *  an Error.\n */\nexport function convertToPlainObject<V>(\n  value: V,\n):\n  | {\n      [ownProps: string]: unknown;\n      type: string;\n      target: string;\n      currentTarget: string;\n      detail?: unknown;\n    }\n  | {\n      [ownProps: string]: unknown;\n      message: string;\n      name: string;\n      stack?: string;\n    }\n  | V {\n  if (isError(value)) {\n    return {\n      message: value.message,\n      name: value.name,\n      stack: value.stack,\n      ...getOwnProperties(value),\n    };\n  } else if (isEvent(value)) {\n    const newObj: {\n      [ownProps: string]: unknown;\n      type: string;\n      target: string;\n      currentTarget: string;\n      detail?: unknown;\n    } = {\n      type: value.type,\n      target: serializeEventTarget(value.target),\n      currentTarget: serializeEventTarget(value.currentTarget),\n      ...getOwnProperties(value),\n    };\n\n    if (typeof CustomEvent !== 'undefined' && isInstanceOf(value, CustomEvent)) {\n      newObj.detail = value.detail;\n    }\n\n    return newObj;\n  } else {\n    return value;\n  }\n}\n\n/** Creates a string representation of the target of an `Event` object */\nfunction serializeEventTarget(target: unknown): string {\n  try {\n    return isElement(target) ? htmlTreeAsString(target) : Object.prototype.toString.call(target);\n  } catch (_oO) {\n    return '<unknown>';\n  }\n}\n\n/** Filters out all but an object's own properties */\nfunction getOwnProperties(obj: unknown): { [key: string]: unknown } {\n  if (typeof obj === 'object' && obj !== null) {\n    const extractedProps: { [key: string]: unknown } = {};\n    for (const property in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, property)) {\n        extractedProps[property] = (obj as Record<string, unknown>)[property];\n      }\n    }\n    return extractedProps;\n  } else {\n    return {};\n  }\n}\n\n/**\n * Given any captured exception, extract its keys and create a sorted\n * and truncated list that will be used inside the event message.\n * eg. `Non-error exception captured with keys: foo, bar, baz`\n */\nexport function extractExceptionKeysForMessage(exception: Record<string, unknown>, maxLength: number = 40): string {\n  const keys = Object.keys(convertToPlainObject(exception));\n  keys.sort();\n\n  if (!keys.length) {\n    return '[object has no keys]';\n  }\n\n  if (keys[0].length >= maxLength) {\n    return truncate(keys[0], maxLength);\n  }\n\n  for (let includedKeys = keys.length; includedKeys > 0; includedKeys--) {\n    const serialized = keys.slice(0, includedKeys).join(', ');\n    if (serialized.length > maxLength) {\n      continue;\n    }\n    if (includedKeys === keys.length) {\n      return serialized;\n    }\n    return truncate(serialized, maxLength);\n  }\n\n  return '';\n}\n\n/**\n * Given any object, return a new object having removed all fields whose value was `undefined`.\n * Works recursively on objects and arrays.\n *\n * Attention: This function keeps circular references in the returned object.\n */\nexport function dropUndefinedKeys<T>(inputValue: T): T {\n  // This map keeps track of what already visited nodes map to.\n  // Our Set - based memoBuilder doesn't work here because we want to the output object to have the same circular\n  // references as the input object.\n  const memoizationMap = new Map<unknown, unknown>();\n\n  // This function just proxies `_dropUndefinedKeys` to keep the `memoBuilder` out of this function's API\n  return _dropUndefinedKeys(inputValue, memoizationMap);\n}\n\nfunction _dropUndefinedKeys<T>(inputValue: T, memoizationMap: Map<unknown, unknown>): T {\n  if (isPojo(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the object it was mapped to in the new object\n    const memoVal = memoizationMap.get(inputValue);\n    if (memoVal !== undefined) {\n      return memoVal as T;\n    }\n\n    const returnValue: { [key: string]: any } = {};\n    // Store the mapping of this value in case we visit it again, in case of circular data\n    memoizationMap.set(inputValue, returnValue);\n\n    for (const key of Object.keys(inputValue)) {\n      if (typeof inputValue[key] !== 'undefined') {\n        returnValue[key] = _dropUndefinedKeys(inputValue[key], memoizationMap);\n      }\n    }\n\n    return returnValue as T;\n  }\n\n  if (Array.isArray(inputValue)) {\n    // If this node has already been visited due to a circular reference, return the array it was mapped to in the new object\n    const memoVal = memoizationMap.get(inputValue);\n    if (memoVal !== undefined) {\n      return memoVal as T;\n    }\n\n    const returnValue: unknown[] = [];\n    // Store the mapping of this value in case we visit it again, in case of circular data\n    memoizationMap.set(inputValue, returnValue);\n\n    inputValue.forEach((item: unknown) => {\n      returnValue.push(_dropUndefinedKeys(item, memoizationMap));\n    });\n\n    return returnValue as unknown as T;\n  }\n\n  return inputValue;\n}\n\nfunction isPojo(input: unknown): input is Record<string, unknown> {\n  if (!isPlainObject(input)) {\n    return false;\n  }\n\n  try {\n    const name = (Object.getPrototypeOf(input) as { constructor: { name: string } }).constructor.name;\n    return !name || name === 'Object';\n  } catch {\n    return true;\n  }\n}\n\n/**\n * Ensure that something is an object.\n *\n * Turns `undefined` and `null` into `String`s and all other primitives into instances of their respective wrapper\n * classes (String, Boolean, Number, etc.). Acts as the identity function on non-primitives.\n *\n * @param wat The subject of the objectification\n * @returns A version of `wat` which can safely be used with `Object` class methods\n */\nexport function objectify(wat: unknown): typeof Object {\n  let objectified;\n  switch (true) {\n    case wat === undefined || wat === null:\n      objectified = new String(wat);\n      break;\n\n    // Though symbols and bigints do have wrapper classes (`Symbol` and `BigInt`, respectively), for whatever reason\n    // those classes don't have constructors which can be used with the `new` keyword. We therefore need to cast each as\n    // an object in order to wrap it.\n    case typeof wat === 'symbol' || typeof wat === 'bigint':\n      objectified = Object(wat);\n      break;\n\n    // this will catch the remaining primitives: `String`, `Number`, and `Boolean`\n    case isPrimitive(wat):\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      objectified = new (wat as any).constructor(wat);\n      break;\n\n    // by process of elimination, at this point we know that `wat` must already be an object\n    default:\n      objectified = wat;\n      break;\n  }\n  return objectified;\n}\n","import type { PropagationContext, TraceparentData } from '@sentry/types';\n\nimport { baggageHeaderToDynamicSamplingContext } from './baggage';\nimport { uuid4 } from './misc';\n\n// eslint-disable-next-line @sentry-internal/sdk/no-regexp-constructor -- RegExp is used for readability here\nexport const TRACEPARENT_REGEXP = new RegExp(\n  '^[ \\\\t]*' + // whitespace\n    '([0-9a-f]{32})?' + // trace_id\n    '-?([0-9a-f]{16})?' + // span_id\n    '-?([01])?' + // sampled\n    '[ \\\\t]*$', // whitespace\n);\n\n/**\n * Extract transaction context data from a `sentry-trace` header.\n *\n * @param traceparent Traceparent string\n *\n * @returns Object containing data from the header, or undefined if traceparent string is malformed\n */\nexport function extractTraceparentData(traceparent?: string): TraceparentData | undefined {\n  if (!traceparent) {\n    return undefined;\n  }\n\n  const matches = traceparent.match(TRACEPARENT_REGEXP);\n  if (!matches) {\n    return undefined;\n  }\n\n  let parentSampled: boolean | undefined;\n  if (matches[3] === '1') {\n    parentSampled = true;\n  } else if (matches[3] === '0') {\n    parentSampled = false;\n  }\n\n  return {\n    traceId: matches[1],\n    parentSampled,\n    parentSpanId: matches[2],\n  };\n}\n\n/**\n * Create tracing context from incoming headers.\n *\n * @deprecated Use `propagationContextFromHeaders` instead.\n */\n// TODO(v8): Remove this function\nexport function tracingContextFromHeaders(\n  sentryTrace: Parameters<typeof extractTraceparentData>[0],\n  baggage: Parameters<typeof baggageHeaderToDynamicSamplingContext>[0],\n): {\n  traceparentData: ReturnType<typeof extractTraceparentData>;\n  dynamicSamplingContext: ReturnType<typeof baggageHeaderToDynamicSamplingContext>;\n  propagationContext: PropagationContext;\n} {\n  const traceparentData = extractTraceparentData(sentryTrace);\n  const dynamicSamplingContext = baggageHeaderToDynamicSamplingContext(baggage);\n\n  const { traceId, parentSpanId, parentSampled } = traceparentData || {};\n\n  if (!traceparentData) {\n    return {\n      traceparentData,\n      dynamicSamplingContext: undefined,\n      propagationContext: {\n        traceId: traceId || uuid4(),\n        spanId: uuid4().substring(16),\n      },\n    };\n  } else {\n    return {\n      traceparentData,\n      dynamicSamplingContext: dynamicSamplingContext || {}, // If we have traceparent data but no DSC it means we are not head of trace and we must freeze it\n      propagationContext: {\n        traceId: traceId || uuid4(),\n        parentSpanId: parentSpanId || uuid4().substring(16),\n        spanId: uuid4().substring(16),\n        sampled: parentSampled,\n        dsc: dynamicSamplingContext || {}, // If we have traceparent data but no DSC it means we are not head of trace and we must freeze it\n      },\n    };\n  }\n}\n\n/**\n * Create a propagation context from incoming headers.\n */\nexport function propagationContextFromHeaders(\n  sentryTrace: string | undefined,\n  baggage: string | number | boolean | string[] | null | undefined,\n): PropagationContext {\n  const traceparentData = extractTraceparentData(sentryTrace);\n  const dynamicSamplingContext = baggageHeaderToDynamicSamplingContext(baggage);\n\n  const { traceId, parentSpanId, parentSampled } = traceparentData || {};\n\n  if (!traceparentData) {\n    return {\n      traceId: traceId || uuid4(),\n      spanId: uuid4().substring(16),\n    };\n  } else {\n    return {\n      traceId: traceId || uuid4(),\n      parentSpanId: parentSpanId || uuid4().substring(16),\n      spanId: uuid4().substring(16),\n      sampled: parentSampled,\n      dsc: dynamicSamplingContext || {}, // If we have traceparent data but no DSC it means we are not head of trace and we must freeze it\n    };\n  }\n}\n\n/**\n * Create sentry-trace header from span context values.\n */\nexport function generateSentryTraceHeader(\n  traceId: string = uuid4(),\n  spanId: string = uuid4().substring(16),\n  sampled?: boolean,\n): string {\n  let sampledString = '';\n  if (sampled !== undefined) {\n    sampledString = sampled ? '-1' : '-0';\n  }\n  return `${traceId}-${spanId}${sampledString}`;\n}\n","import {\n  addGlobalErrorInstrumentationHandler,\n  addGlobalUnhandledRejectionInstrumentationHandler,\n  logger,\n} from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport type { SpanStatusType } from './spanstatus';\nimport { getActiveTransaction } from './utils';\n\nlet errorsInstrumented = false;\n\n/**\n * Configures global error listeners\n */\nexport function registerErrorInstrumentation(): void {\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 transaction as failed\n */\nfunction errorCallback(): void {\n  // eslint-disable-next-line deprecation/deprecation\n  const activeTransaction = getActiveTransaction();\n  if (activeTransaction) {\n    const status: SpanStatusType = 'internal_error';\n    DEBUG_BUILD && logger.log(`[Tracing] Transaction: ${status} -> Global error occured`);\n    activeTransaction.setStatus(status);\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","import type { ClientOptions, CustomSamplingContext, TransactionContext } from '@sentry/types';\nimport { logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport type { Hub } from '../hub';\nimport { getMainCarrier } from '../hub';\nimport { spanToTraceHeader } from '../utils/spanUtils';\nimport { registerErrorInstrumentation } from './errors';\nimport { IdleTransaction } from './idletransaction';\nimport { sampleTransaction } from './sampling';\nimport { Transaction } from './transaction';\n\n/** Returns all trace headers that are currently on the top scope. */\n// eslint-disable-next-line deprecation/deprecation\nfunction traceHeaders(this: Hub): { [key: string]: string } {\n  // eslint-disable-next-line deprecation/deprecation\n  const scope = this.getScope();\n  // eslint-disable-next-line deprecation/deprecation\n  const span = scope.getSpan();\n\n  return span\n    ? {\n        'sentry-trace': spanToTraceHeader(span),\n      }\n    : {};\n}\n\n/**\n * Creates a new transaction and adds a sampling decision if it doesn't yet have one.\n *\n * The Hub.startTransaction method delegates to this method to do its work, passing the Hub instance in as `this`, as if\n * it had been called on the hub directly. Exists as a separate function so that it can be injected into the class as an\n * \"extension method.\"\n *\n * @param this: The Hub starting the transaction\n * @param transactionContext: Data used to configure the transaction\n * @param CustomSamplingContext: Optional data to be provided to the `tracesSampler` function (if any)\n *\n * @returns The new transaction\n *\n * @see {@link Hub.startTransaction}\n */\nfunction _startTransaction(\n  // eslint-disable-next-line deprecation/deprecation\n  this: Hub,\n  transactionContext: TransactionContext,\n  customSamplingContext?: CustomSamplingContext,\n): Transaction {\n  // eslint-disable-next-line deprecation/deprecation\n  const client = this.getClient();\n  const options: Partial<ClientOptions> = (client && client.getOptions()) || {};\n\n  const configInstrumenter = options.instrumenter || 'sentry';\n  const transactionInstrumenter = transactionContext.instrumenter || 'sentry';\n\n  if (configInstrumenter !== transactionInstrumenter) {\n    DEBUG_BUILD &&\n      logger.error(\n        `A transaction was started with instrumenter=\\`${transactionInstrumenter}\\`, but the SDK is configured with the \\`${configInstrumenter}\\` instrumenter.\nThe transaction will not be sampled. Please use the ${configInstrumenter} instrumentation to start transactions.`,\n      );\n\n    // eslint-disable-next-line deprecation/deprecation\n    transactionContext.sampled = false;\n  }\n\n  // eslint-disable-next-line deprecation/deprecation\n  let transaction = new Transaction(transactionContext, this);\n  transaction = sampleTransaction(transaction, options, {\n    name: transactionContext.name,\n    parentSampled: transactionContext.parentSampled,\n    transactionContext,\n    attributes: {\n      // eslint-disable-next-line deprecation/deprecation\n      ...transactionContext.data,\n      ...transactionContext.attributes,\n    },\n    ...customSamplingContext,\n  });\n  if (transaction.isRecording()) {\n    transaction.initSpanRecorder(options._experiments && (options._experiments.maxSpans as number));\n  }\n  if (client && client.emit) {\n    client.emit('startTransaction', transaction);\n  }\n  return transaction;\n}\n\n/**\n * Create new idle transaction.\n */\nexport function startIdleTransaction(\n  // eslint-disable-next-line deprecation/deprecation\n  hub: Hub,\n  transactionContext: TransactionContext,\n  idleTimeout: number,\n  finalTimeout: number,\n  onScope?: boolean,\n  customSamplingContext?: CustomSamplingContext,\n  heartbeatInterval?: number,\n  delayAutoFinishUntilSignal: boolean = false,\n): IdleTransaction {\n  // eslint-disable-next-line deprecation/deprecation\n  const client = hub.getClient();\n  const options: Partial<ClientOptions> = (client && client.getOptions()) || {};\n\n  // eslint-disable-next-line deprecation/deprecation\n  let transaction = new IdleTransaction(\n    transactionContext,\n    hub,\n    idleTimeout,\n    finalTimeout,\n    heartbeatInterval,\n    onScope,\n    delayAutoFinishUntilSignal,\n  );\n  transaction = sampleTransaction(transaction, options, {\n    name: transactionContext.name,\n    parentSampled: transactionContext.parentSampled,\n    transactionContext,\n    attributes: {\n      // eslint-disable-next-line deprecation/deprecation\n      ...transactionContext.data,\n      ...transactionContext.attributes,\n    },\n    ...customSamplingContext,\n  });\n  if (transaction.isRecording()) {\n    transaction.initSpanRecorder(options._experiments && (options._experiments.maxSpans as number));\n  }\n  if (client && client.emit) {\n    client.emit('startTransaction', transaction);\n  }\n  return transaction;\n}\n\n/**\n * Adds tracing extensions to the global hub.\n */\nexport function addTracingExtensions(): void {\n  const carrier = getMainCarrier();\n  if (!carrier.__SENTRY__) {\n    return;\n  }\n  carrier.__SENTRY__.extensions = carrier.__SENTRY__.extensions || {};\n  if (!carrier.__SENTRY__.extensions.startTransaction) {\n    carrier.__SENTRY__.extensions.startTransaction = _startTransaction;\n  }\n  if (!carrier.__SENTRY__.extensions.traceHeaders) {\n    carrier.__SENTRY__.extensions.traceHeaders = traceHeaders;\n  }\n\n  registerErrorInstrumentation();\n}\n","import type { Span } from '@sentry/types';\n\n/**\n * Returns the root span of a given span.\n *\n * As long as we use `Transaction`s internally, the returned root span\n * will be a `Transaction` but be aware that this might change in the future.\n *\n * If the given span has no root span or transaction, `undefined` is returned.\n */\nexport function getRootSpan(span: Span): Span | undefined {\n  // TODO (v8): Remove this check and just return span\n  // eslint-disable-next-line deprecation/deprecation\n  return span.transaction;\n}\n","// TODO(v8): Move everything in this file into the browser package. Nothing here is generic and we run risk of leaking browser types into non-browser packages.\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/ban-types */\nimport type { HandlerDataDom } from '@sentry/types';\n\nimport { uuid4 } from '../misc';\nimport { addNonEnumerableProperty, fill } from '../object';\nimport { GLOBAL_OBJ } from '../worldwide';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers';\n\ntype SentryWrappedTarget = HTMLElement & { _sentryId?: string };\n\ntype AddEventListener = (\n  type: string,\n  listener: EventListenerOrEventListenerObject,\n  options?: boolean | AddEventListenerOptions,\n) => void;\ntype RemoveEventListener = (\n  type: string,\n  listener: EventListenerOrEventListenerObject,\n  options?: boolean | EventListenerOptions,\n) => void;\n\ntype InstrumentedElement = Element & {\n  __sentry_instrumentation_handlers__?: {\n    [key in 'click' | 'keypress']?: {\n      handler?: Function;\n      /** The number of custom listeners attached to this element */\n      refCount: number;\n    };\n  };\n};\n\nconst WINDOW = GLOBAL_OBJ as unknown as Window;\nconst DEBOUNCE_DURATION = 1000;\n\nlet debounceTimerID: number | undefined;\nlet lastCapturedEventType: string | undefined;\nlet lastCapturedEventTargetId: string | undefined;\n\n/**\n * Add an instrumentation handler for when a click or a keypress happens.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addClickKeypressInstrumentationHandler(handler: (data: HandlerDataDom) => void): void {\n  const type = 'dom';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentDOM);\n}\n\n/** Exported for tests only. */\nexport function instrumentDOM(): void {\n  if (!WINDOW.document) {\n    return;\n  }\n\n  // Make it so that any click or keypress that is unhandled / bubbled up all the way to the document triggers our dom\n  // handlers. (Normally we have only one, which captures a breadcrumb for each click or keypress.) Do this before\n  // we instrument `addEventListener` so that we don't end up attaching this handler twice.\n  const triggerDOMHandler = triggerHandlers.bind(null, 'dom');\n  const globalDOMEventHandler = makeDOMEventHandler(triggerDOMHandler, true);\n  WINDOW.document.addEventListener('click', globalDOMEventHandler, false);\n  WINDOW.document.addEventListener('keypress', globalDOMEventHandler, false);\n\n  // After hooking into click and keypress events bubbled up to `document`, we also hook into user-handled\n  // clicks & keypresses, by adding an event listener of our own to any element to which they add a listener. That\n  // way, whenever one of their handlers is triggered, ours will be, too. (This is needed because their handler\n  // could potentially prevent the event from bubbling up to our global listeners. This way, our handler are still\n  // guaranteed to fire at least once.)\n  ['EventTarget', 'Node'].forEach((target: string) => {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n    const proto = (WINDOW as any)[target] && (WINDOW as any)[target].prototype;\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, no-prototype-builtins\n    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n      return;\n    }\n\n    fill(proto, 'addEventListener', function (originalAddEventListener: AddEventListener): AddEventListener {\n      return function (\n        this: Element,\n        type: string,\n        listener: EventListenerOrEventListenerObject,\n        options?: boolean | AddEventListenerOptions,\n      ): AddEventListener {\n        if (type === 'click' || type == 'keypress') {\n          try {\n            const el = this as InstrumentedElement;\n            const handlers = (el.__sentry_instrumentation_handlers__ = el.__sentry_instrumentation_handlers__ || {});\n            const handlerForType = (handlers[type] = handlers[type] || { refCount: 0 });\n\n            if (!handlerForType.handler) {\n              const handler = makeDOMEventHandler(triggerDOMHandler);\n              handlerForType.handler = handler;\n              originalAddEventListener.call(this, type, handler, options);\n            }\n\n            handlerForType.refCount++;\n          } catch (e) {\n            // Accessing dom properties is always fragile.\n            // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n          }\n        }\n\n        return originalAddEventListener.call(this, type, listener, options);\n      };\n    });\n\n    fill(\n      proto,\n      'removeEventListener',\n      function (originalRemoveEventListener: RemoveEventListener): RemoveEventListener {\n        return function (\n          this: Element,\n          type: string,\n          listener: EventListenerOrEventListenerObject,\n          options?: boolean | EventListenerOptions,\n        ): () => void {\n          if (type === 'click' || type == 'keypress') {\n            try {\n              const el = this as InstrumentedElement;\n              const handlers = el.__sentry_instrumentation_handlers__ || {};\n              const handlerForType = handlers[type];\n\n              if (handlerForType) {\n                handlerForType.refCount--;\n                // If there are no longer any custom handlers of the current type on this element, we can remove ours, too.\n                if (handlerForType.refCount <= 0) {\n                  originalRemoveEventListener.call(this, type, handlerForType.handler, options);\n                  handlerForType.handler = undefined;\n                  delete handlers[type]; // eslint-disable-line @typescript-eslint/no-dynamic-delete\n                }\n\n                // If there are no longer any custom handlers of any type on this element, cleanup everything.\n                if (Object.keys(handlers).length === 0) {\n                  delete el.__sentry_instrumentation_handlers__;\n                }\n              }\n            } catch (e) {\n              // Accessing dom properties is always fragile.\n              // Also allows us to skip `addEventListenrs` calls with no proper `this` context.\n            }\n          }\n\n          return originalRemoveEventListener.call(this, type, listener, options);\n        };\n      },\n    );\n  });\n}\n\n/**\n * Check whether the event is similar to the last captured one. For example, two click events on the same button.\n */\nfunction isSimilarToLastCapturedEvent(event: Event): boolean {\n  // If both events have different type, then user definitely performed two separate actions. e.g. click + keypress.\n  if (event.type !== lastCapturedEventType) {\n    return false;\n  }\n\n  try {\n    // If both events have the same type, it's still possible that actions were performed on different targets.\n    // e.g. 2 clicks on different buttons.\n    if (!event.target || (event.target as SentryWrappedTarget)._sentryId !== lastCapturedEventTargetId) {\n      return false;\n    }\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n  }\n\n  // If both events have the same type _and_ same `target` (an element which triggered an event, _not necessarily_\n  // to which an event listener was attached), we treat them as the same action, as we want to capture\n  // only one breadcrumb. e.g. multiple clicks on the same button, or typing inside a user input box.\n  return true;\n}\n\n/**\n * Decide whether an event should be captured.\n * @param event event to be captured\n */\nfunction shouldSkipDOMEvent(eventType: string, target: SentryWrappedTarget | null): boolean {\n  // We are only interested in filtering `keypress` events for now.\n  if (eventType !== 'keypress') {\n    return false;\n  }\n\n  if (!target || !target.tagName) {\n    return true;\n  }\n\n  // Only consider keypress events on actual input elements. This will disregard keypresses targeting body\n  // e.g.tabbing through elements, hotkeys, etc.\n  if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Wraps addEventListener to capture UI breadcrumbs\n */\nfunction makeDOMEventHandler(\n  handler: (data: HandlerDataDom) => void,\n  globalListener: boolean = false,\n): (event: Event) => void {\n  return (event: Event & { _sentryCaptured?: true }): void => {\n    // It's possible this handler might trigger multiple times for the same\n    // event (e.g. event propagation through node ancestors).\n    // Ignore if we've already captured that event.\n    if (!event || event['_sentryCaptured']) {\n      return;\n    }\n\n    const target = getEventTarget(event);\n\n    // We always want to skip _some_ events.\n    if (shouldSkipDOMEvent(event.type, target)) {\n      return;\n    }\n\n    // Mark event as \"seen\"\n    addNonEnumerableProperty(event, '_sentryCaptured', true);\n\n    if (target && !target._sentryId) {\n      // Add UUID to event target so we can identify if\n      addNonEnumerableProperty(target, '_sentryId', uuid4());\n    }\n\n    const name = event.type === 'keypress' ? 'input' : event.type;\n\n    // If there is no last captured event, it means that we can safely capture the new event and store it for future comparisons.\n    // If there is a last captured event, see if the new event is different enough to treat it as a unique one.\n    // If that's the case, emit the previous event and store locally the newly-captured DOM event.\n    if (!isSimilarToLastCapturedEvent(event)) {\n      const handlerData: HandlerDataDom = { event, name, global: globalListener };\n      handler(handlerData);\n      lastCapturedEventType = event.type;\n      lastCapturedEventTargetId = target ? target._sentryId : undefined;\n    }\n\n    // Start a new debounce timer that will prevent us from capturing multiple events that should be grouped together.\n    clearTimeout(debounceTimerID);\n    debounceTimerID = WINDOW.setTimeout(() => {\n      lastCapturedEventTargetId = undefined;\n      lastCapturedEventType = undefined;\n    }, DEBOUNCE_DURATION);\n  };\n}\n\nfunction getEventTarget(event: Event): SentryWrappedTarget | null {\n  try {\n    return event.target as SentryWrappedTarget | null;\n  } catch (e) {\n    // just accessing `target` property can throw an exception in some rare circumstances\n    // see: https://github.com/getsentry/sentry-javascript/issues/838\n    return null;\n  }\n}\n","export const SDK_VERSION = '7.120.3';\n","import type {\n  Attachment,\n  AttachmentItem,\n  BaseEnvelopeHeaders,\n  BaseEnvelopeItemHeaders,\n  DataCategory,\n  DsnComponents,\n  Envelope,\n  EnvelopeItemType,\n  Event,\n  EventEnvelopeHeaders,\n  SdkInfo,\n  SdkMetadata,\n  TextEncoderInternal,\n} from '@sentry/types';\n\nimport { dsnToString } from './dsn';\nimport { normalize } from './normalize';\nimport { dropUndefinedKeys } from './object';\n\n/**\n * Creates an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nexport function createEnvelope<E extends Envelope>(headers: E[0], items: E[1] = []): E {\n  return [headers, items] as E;\n}\n\n/**\n * Add an item to an envelope.\n * Make sure to always explicitly provide the generic to this function\n * so that the envelope types resolve correctly.\n */\nexport function addItemToEnvelope<E extends Envelope>(envelope: E, newItem: E[1][number]): E {\n  const [headers, items] = envelope;\n  return [headers, [...items, newItem]] as unknown as E;\n}\n\n/**\n * Convenience function to loop through the items and item types of an envelope.\n * (This function was mostly created because working with envelope types is painful at the moment)\n *\n * If the callback returns true, the rest of the items will be skipped.\n */\nexport function forEachEnvelopeItem<E extends Envelope>(\n  envelope: Envelope,\n  callback: (envelopeItem: E[1][number], envelopeItemType: E[1][number][0]['type']) => boolean | void,\n): boolean {\n  const envelopeItems = envelope[1];\n\n  for (const envelopeItem of envelopeItems) {\n    const envelopeItemType = envelopeItem[0].type;\n    const result = callback(envelopeItem, envelopeItemType);\n\n    if (result) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Returns true if the envelope contains any of the given envelope item types\n */\nexport function envelopeContainsItemType(envelope: Envelope, types: EnvelopeItemType[]): boolean {\n  return forEachEnvelopeItem(envelope, (_, type) => types.includes(type));\n}\n\n/**\n * Encode a string to UTF8.\n */\nfunction encodeUTF8(input: string, textEncoder?: TextEncoderInternal): Uint8Array {\n  const utf8 = textEncoder || new TextEncoder();\n  return utf8.encode(input);\n}\n\n/**\n * Serializes an envelope.\n */\nexport function serializeEnvelope(envelope: Envelope, textEncoder?: TextEncoderInternal): string | Uint8Array {\n  const [envHeaders, items] = envelope;\n\n  // Initially we construct our envelope as a string and only convert to binary chunks if we encounter binary data\n  let parts: string | Uint8Array[] = JSON.stringify(envHeaders);\n\n  function append(next: string | Uint8Array): void {\n    if (typeof parts === 'string') {\n      parts = typeof next === 'string' ? parts + next : [encodeUTF8(parts, textEncoder), next];\n    } else {\n      parts.push(typeof next === 'string' ? encodeUTF8(next, textEncoder) : next);\n    }\n  }\n\n  for (const item of items) {\n    const [itemHeaders, payload] = item;\n\n    append(`\\n${JSON.stringify(itemHeaders)}\\n`);\n\n    if (typeof payload === 'string' || payload instanceof Uint8Array) {\n      append(payload);\n    } else {\n      let stringifiedPayload: string;\n      try {\n        stringifiedPayload = JSON.stringify(payload);\n      } catch (e) {\n        // In case, despite all our efforts to keep `payload` circular-dependency-free, `JSON.strinify()` still\n        // fails, we try again after normalizing it again with infinite normalization depth. This of course has a\n        // performance impact but in this case a performance hit is better than throwing.\n        stringifiedPayload = JSON.stringify(normalize(payload));\n      }\n      append(stringifiedPayload);\n    }\n  }\n\n  return typeof parts === 'string' ? parts : concatBuffers(parts);\n}\n\nfunction concatBuffers(buffers: Uint8Array[]): Uint8Array {\n  const totalLength = buffers.reduce((acc, buf) => acc + buf.length, 0);\n\n  const merged = new Uint8Array(totalLength);\n  let offset = 0;\n  for (const buffer of buffers) {\n    merged.set(buffer, offset);\n    offset += buffer.length;\n  }\n\n  return merged;\n}\n\nexport interface TextDecoderInternal {\n  decode(input?: Uint8Array): string;\n}\n\n/**\n * Parses an envelope\n */\nexport function parseEnvelope(\n  env: string | Uint8Array,\n  textEncoder: TextEncoderInternal,\n  textDecoder: TextDecoderInternal,\n): Envelope {\n  let buffer = typeof env === 'string' ? textEncoder.encode(env) : env;\n\n  function readBinary(length: number): Uint8Array {\n    const bin = buffer.subarray(0, length);\n    // Replace the buffer with the remaining data excluding trailing newline\n    buffer = buffer.subarray(length + 1);\n    return bin;\n  }\n\n  function readJson<T>(): T {\n    let i = buffer.indexOf(0xa);\n    // If we couldn't find a newline, we must have found the end of the buffer\n    if (i < 0) {\n      i = buffer.length;\n    }\n\n    return JSON.parse(textDecoder.decode(readBinary(i))) as T;\n  }\n\n  const envelopeHeader = readJson<BaseEnvelopeHeaders>();\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const items: [any, any][] = [];\n\n  while (buffer.length) {\n    const itemHeader = readJson<BaseEnvelopeItemHeaders>();\n    const binaryLength = typeof itemHeader.length === 'number' ? itemHeader.length : undefined;\n\n    items.push([itemHeader, binaryLength ? readBinary(binaryLength) : readJson()]);\n  }\n\n  return [envelopeHeader, items];\n}\n\n/**\n * Creates attachment envelope items\n */\nexport function createAttachmentEnvelopeItem(\n  attachment: Attachment,\n  textEncoder?: TextEncoderInternal,\n): AttachmentItem {\n  const buffer = typeof attachment.data === 'string' ? encodeUTF8(attachment.data, textEncoder) : attachment.data;\n\n  return [\n    dropUndefinedKeys({\n      type: 'attachment',\n      length: buffer.length,\n      filename: attachment.filename,\n      content_type: attachment.contentType,\n      attachment_type: attachment.attachmentType,\n    }),\n    buffer,\n  ];\n}\n\nconst ITEM_TYPE_TO_DATA_CATEGORY_MAP: Record<EnvelopeItemType, DataCategory> = {\n  session: 'session',\n  sessions: 'session',\n  attachment: 'attachment',\n  transaction: 'transaction',\n  event: 'error',\n  client_report: 'internal',\n  user_report: 'default',\n  profile: 'profile',\n  replay_event: 'replay',\n  replay_recording: 'replay',\n  check_in: 'monitor',\n  feedback: 'feedback',\n  span: 'span',\n  statsd: 'metric_bucket',\n};\n\n/**\n * Maps the type of an envelope item to a data category.\n */\nexport function envelopeItemTypeToDataCategory(type: EnvelopeItemType): DataCategory {\n  return ITEM_TYPE_TO_DATA_CATEGORY_MAP[type];\n}\n\n/** Extracts the minimal SDK info from the metadata or an events */\nexport function getSdkMetadataForEnvelopeHeader(metadataOrEvent?: SdkMetadata | Event): SdkInfo | undefined {\n  if (!metadataOrEvent || !metadataOrEvent.sdk) {\n    return;\n  }\n  const { name, version } = metadataOrEvent.sdk;\n  return { name, version };\n}\n\n/**\n * Creates event envelope headers, based on event, sdk info and tunnel\n * Note: This function was extracted from the core package to make it available in Replay\n */\nexport function createEventEnvelopeHeaders(\n  event: Event,\n  sdkInfo: SdkInfo | undefined,\n  tunnel: string | undefined,\n  dsn?: DsnComponents,\n): EventEnvelopeHeaders {\n  const dynamicSamplingContext = event.sdkProcessingMetadata && event.sdkProcessingMetadata.dynamicSamplingContext;\n  return {\n    event_id: event.event_id as string,\n    sent_at: new Date().toISOString(),\n    ...(sdkInfo && { sdk: sdkInfo }),\n    ...(!!tunnel && dsn && { dsn: dsnToString(dsn) }),\n    ...(dynamicSamplingContext && {\n      trace: dropUndefinedKeys({ ...dynamicSamplingContext }),\n    }),\n  };\n}\n","import type { DataCategory, TransportMakeRequestResponse } from '@sentry/types';\n\n// Intentionally keeping the key broad, as we don't know for sure what rate limit headers get returned from backend\nexport type RateLimits = Record<string, number>;\n\nexport const DEFAULT_RETRY_AFTER = 60 * 1000; // 60 seconds\n\n/**\n * Extracts Retry-After value from the request header or returns default value\n * @param header string representation of 'Retry-After' header\n * @param now current unix timestamp\n *\n */\nexport function parseRetryAfterHeader(header: string, now: number = Date.now()): number {\n  const headerDelay = parseInt(`${header}`, 10);\n  if (!isNaN(headerDelay)) {\n    return headerDelay * 1000;\n  }\n\n  const headerDate = Date.parse(`${header}`);\n  if (!isNaN(headerDate)) {\n    return headerDate - now;\n  }\n\n  return DEFAULT_RETRY_AFTER;\n}\n\n/**\n * Gets the time that the given category is disabled until for rate limiting.\n * In case no category-specific limit is set but a general rate limit across all categories is active,\n * that time is returned.\n *\n * @return the time in ms that the category is disabled until or 0 if there's no active rate limit.\n */\nexport function disabledUntil(limits: RateLimits, dataCategory: DataCategory): number {\n  return limits[dataCategory] || limits.all || 0;\n}\n\n/**\n * Checks if a category is rate limited\n */\nexport function isRateLimited(limits: RateLimits, dataCategory: DataCategory, now: number = Date.now()): boolean {\n  return disabledUntil(limits, dataCategory) > now;\n}\n\n/**\n * Update ratelimits from incoming headers.\n *\n * @return the updated RateLimits object.\n */\nexport function updateRateLimits(\n  limits: RateLimits,\n  { statusCode, headers }: TransportMakeRequestResponse,\n  now: number = Date.now(),\n): RateLimits {\n  const updatedRateLimits: RateLimits = {\n    ...limits,\n  };\n\n  // \"The name is case-insensitive.\"\n  // https://developer.mozilla.org/en-US/docs/Web/API/Headers/get\n  const rateLimitHeader = headers && headers['x-sentry-rate-limits'];\n  const retryAfterHeader = headers && headers['retry-after'];\n\n  if (rateLimitHeader) {\n    /**\n     * rate limit headers are of the form\n     *     <header>,<header>,..\n     * where each <header> is of the form\n     *     <retry_after>: <categories>: <scope>: <reason_code>: <namespaces>\n     * where\n     *     <retry_after> is a delay in seconds\n     *     <categories> is the event type(s) (error, transaction, etc) being rate limited and is of the form\n     *         <category>;<category>;...\n     *     <scope> is what's being limited (org, project, or key) - ignored by SDK\n     *     <reason_code> is an arbitrary string like \"org_quota\" - ignored by SDK\n     *     <namespaces> Semicolon-separated list of metric namespace identifiers. Defines which namespace(s) will be affected.\n     *         Only present if rate limit applies to the metric_bucket data category.\n     */\n    for (const limit of rateLimitHeader.trim().split(',')) {\n      const [retryAfter, categories, , , namespaces] = limit.split(':', 5);\n      const headerDelay = parseInt(retryAfter, 10);\n      const delay = (!isNaN(headerDelay) ? headerDelay : 60) * 1000; // 60sec default\n      if (!categories) {\n        updatedRateLimits.all = now + delay;\n      } else {\n        for (const category of categories.split(';')) {\n          if (category === 'metric_bucket') {\n            // namespaces will be present when category === 'metric_bucket'\n            if (!namespaces || namespaces.split(';').includes('custom')) {\n              updatedRateLimits[category] = now + delay;\n            }\n          } else {\n            updatedRateLimits[category] = now + delay;\n          }\n        }\n      }\n    }\n  } else if (retryAfterHeader) {\n    updatedRateLimits.all = now + parseRetryAfterHeader(retryAfterHeader, now);\n  } else if (statusCode === 429) {\n    updatedRateLimits.all = now + 60 * 1000;\n  }\n\n  return updatedRateLimits;\n}\n","import type { Breadcrumb, Event, ScopeData, Span } from '@sentry/types';\nimport { arrayify, dropUndefinedKeys } from '@sentry/utils';\nimport { getDynamicSamplingContextFromSpan } from '../tracing/dynamicSamplingContext';\nimport { getRootSpan } from './getRootSpan';\nimport { spanToJSON, spanToTraceContext } from './spanUtils';\n\n/**\n * Applies data from the scope to the event and runs all event processors on it.\n */\nexport function applyScopeDataToEvent(event: Event, data: ScopeData): void {\n  const { fingerprint, span, breadcrumbs, sdkProcessingMetadata } = data;\n\n  // Apply general data\n  applyDataToEvent(event, data);\n\n  // We want to set the trace context for normal events only if there isn't already\n  // a trace context on the event. There is a product feature in place where we link\n  // errors with transaction and it relies on that.\n  if (span) {\n    applySpanToEvent(event, span);\n  }\n\n  applyFingerprintToEvent(event, fingerprint);\n  applyBreadcrumbsToEvent(event, breadcrumbs);\n  applySdkMetadataToEvent(event, sdkProcessingMetadata);\n}\n\n/** Merge data of two scopes together. */\nexport function mergeScopeData(data: ScopeData, mergeData: ScopeData): void {\n  const {\n    extra,\n    tags,\n    user,\n    contexts,\n    level,\n    sdkProcessingMetadata,\n    breadcrumbs,\n    fingerprint,\n    eventProcessors,\n    attachments,\n    propagationContext,\n    // eslint-disable-next-line deprecation/deprecation\n    transactionName,\n    span,\n  } = mergeData;\n\n  mergeAndOverwriteScopeData(data, 'extra', extra);\n  mergeAndOverwriteScopeData(data, 'tags', tags);\n  mergeAndOverwriteScopeData(data, 'user', user);\n  mergeAndOverwriteScopeData(data, 'contexts', contexts);\n  mergeAndOverwriteScopeData(data, 'sdkProcessingMetadata', sdkProcessingMetadata);\n\n  if (level) {\n    data.level = level;\n  }\n\n  if (transactionName) {\n    // eslint-disable-next-line deprecation/deprecation\n    data.transactionName = transactionName;\n  }\n\n  if (span) {\n    data.span = span;\n  }\n\n  if (breadcrumbs.length) {\n    data.breadcrumbs = [...data.breadcrumbs, ...breadcrumbs];\n  }\n\n  if (fingerprint.length) {\n    data.fingerprint = [...data.fingerprint, ...fingerprint];\n  }\n\n  if (eventProcessors.length) {\n    data.eventProcessors = [...data.eventProcessors, ...eventProcessors];\n  }\n\n  if (attachments.length) {\n    data.attachments = [...data.attachments, ...attachments];\n  }\n\n  data.propagationContext = { ...data.propagationContext, ...propagationContext };\n}\n\n/**\n * Merges certain scope data. Undefined values will overwrite any existing values.\n * Exported only for tests.\n */\nexport function mergeAndOverwriteScopeData<\n  Prop extends 'extra' | 'tags' | 'user' | 'contexts' | 'sdkProcessingMetadata',\n  Data extends ScopeData,\n>(data: Data, prop: Prop, mergeVal: Data[Prop]): void {\n  if (mergeVal && Object.keys(mergeVal).length) {\n    // Clone object\n    data[prop] = { ...data[prop] };\n    for (const key in mergeVal) {\n      if (Object.prototype.hasOwnProperty.call(mergeVal, key)) {\n        data[prop][key] = mergeVal[key];\n      }\n    }\n  }\n}\n\n/** Exported only for tests */\nexport function mergeArray<Prop extends 'breadcrumbs' | 'fingerprint'>(\n  event: Event,\n  prop: Prop,\n  mergeVal: ScopeData[Prop],\n): void {\n  const prevVal = event[prop];\n  // If we are not merging any new values,\n  // we only need to proceed if there was an empty array before (as we want to replace it with undefined)\n  if (!mergeVal.length && (!prevVal || prevVal.length)) {\n    return;\n  }\n\n  const merged = [...(prevVal || []), ...mergeVal] as ScopeData[Prop];\n  event[prop] = merged.length ? merged : undefined;\n}\n\nfunction applyDataToEvent(event: Event, data: ScopeData): void {\n  const {\n    extra,\n    tags,\n    user,\n    contexts,\n    level,\n    // eslint-disable-next-line deprecation/deprecation\n    transactionName,\n  } = data;\n\n  const cleanedExtra = dropUndefinedKeys(extra);\n  if (cleanedExtra && Object.keys(cleanedExtra).length) {\n    event.extra = { ...cleanedExtra, ...event.extra };\n  }\n\n  const cleanedTags = dropUndefinedKeys(tags);\n  if (cleanedTags && Object.keys(cleanedTags).length) {\n    event.tags = { ...cleanedTags, ...event.tags };\n  }\n\n  const cleanedUser = dropUndefinedKeys(user);\n  if (cleanedUser && Object.keys(cleanedUser).length) {\n    event.user = { ...cleanedUser, ...event.user };\n  }\n\n  const cleanedContexts = dropUndefinedKeys(contexts);\n  if (cleanedContexts && Object.keys(cleanedContexts).length) {\n    event.contexts = { ...cleanedContexts, ...event.contexts };\n  }\n\n  if (level) {\n    event.level = level;\n  }\n\n  if (transactionName) {\n    event.transaction = transactionName;\n  }\n}\n\nfunction applyBreadcrumbsToEvent(event: Event, breadcrumbs: Breadcrumb[]): void {\n  const mergedBreadcrumbs = [...(event.breadcrumbs || []), ...breadcrumbs];\n  event.breadcrumbs = mergedBreadcrumbs.length ? mergedBreadcrumbs : undefined;\n}\n\nfunction applySdkMetadataToEvent(event: Event, sdkProcessingMetadata: ScopeData['sdkProcessingMetadata']): void {\n  event.sdkProcessingMetadata = {\n    ...event.sdkProcessingMetadata,\n    ...sdkProcessingMetadata,\n  };\n}\n\nfunction applySpanToEvent(event: Event, span: Span): void {\n  event.contexts = { trace: spanToTraceContext(span), ...event.contexts };\n  const rootSpan = getRootSpan(span);\n  if (rootSpan) {\n    event.sdkProcessingMetadata = {\n      dynamicSamplingContext: getDynamicSamplingContextFromSpan(span),\n      ...event.sdkProcessingMetadata,\n    };\n    const transactionName = spanToJSON(rootSpan).description;\n    if (transactionName) {\n      event.tags = { transaction: transactionName, ...event.tags };\n    }\n  }\n}\n\n/**\n * Applies fingerprint from the scope to the event if there's one,\n * uses message if there's one instead or get rid of empty fingerprint\n */\nfunction applyFingerprintToEvent(event: Event, fingerprint: ScopeData['fingerprint'] | undefined): void {\n  // Make sure it's an array first and we actually have something in place\n  event.fingerprint = event.fingerprint ? arrayify(event.fingerprint) : [];\n\n  // If we have something on the scope, then merge it with event\n  if (fingerprint) {\n    event.fingerprint = event.fingerprint.concat(fingerprint);\n  }\n\n  // If we have no data at all, remove empty array default\n  if (event.fingerprint && !event.fingerprint.length) {\n    delete event.fingerprint;\n  }\n}\n","/*\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\nimport { WINDOW } from '../../types';\nimport { onHidden } from './onHidden';\n\nlet firstHiddenTime = -1;\n\nconst initHiddenTime = (): void => {\n  // If the document is hidden and not prerendering, assume it was always\n  // hidden and the page was loaded in the background.\n  if (WINDOW.document && WINDOW.document.visibilityState) {\n    firstHiddenTime = WINDOW.document.visibilityState === 'hidden' && !WINDOW.document.prerendering ? 0 : Infinity;\n  }\n};\n\nconst trackChanges = (): void => {\n  // Update the time if/when the document becomes hidden.\n  onHidden(({ timeStamp }) => {\n    firstHiddenTime = timeStamp;\n  }, true);\n};\n\nexport const getVisibilityWatcher = (): {\n  readonly firstHiddenTime: number;\n} => {\n  if (firstHiddenTime < 0) {\n    // If the document is hidden when this code runs, assume it was hidden\n    // since navigation start. This isn't a perfect heuristic, but it's the\n    // best we can do until an API is available to support querying past\n    // visibilityState.\n    initHiddenTime();\n    trackChanges();\n  }\n  return {\n    get firstHiddenTime() {\n      return firstHiddenTime;\n    },\n  };\n};\n","/* eslint-disable @typescript-eslint/no-explicit-any */\nimport type { Event, Exception, Mechanism, StackFrame } from '@sentry/types';\n\nimport { addNonEnumerableProperty } from './object';\nimport { snipLine } from './string';\nimport { GLOBAL_OBJ } from './worldwide';\n\ninterface CryptoInternal {\n  getRandomValues(array: Uint8Array): Uint8Array;\n  randomUUID?(): string;\n}\n\n/** An interface for common properties on global */\ninterface CryptoGlobal {\n  msCrypto?: CryptoInternal;\n  crypto?: CryptoInternal;\n}\n\n/**\n * UUID4 generator\n *\n * @returns string Generated UUID4.\n */\nexport function uuid4(): string {\n  const gbl = GLOBAL_OBJ as typeof GLOBAL_OBJ & CryptoGlobal;\n  const crypto = gbl.crypto || gbl.msCrypto;\n\n  let getRandomByte = (): number => Math.random() * 16;\n  try {\n    if (crypto && crypto.randomUUID) {\n      return crypto.randomUUID().replace(/-/g, '');\n    }\n    if (crypto && crypto.getRandomValues) {\n      getRandomByte = () => {\n        // crypto.getRandomValues might return undefined instead of the typed array\n        // in old Chromium versions (e.g. 23.0.1235.0 (151422))\n        // However, `typedArray` is still filled in-place.\n        // @see https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues#typedarray\n        const typedArray = new Uint8Array(1);\n        crypto.getRandomValues(typedArray);\n        return typedArray[0];\n      };\n    }\n  } catch (_) {\n    // some runtimes can crash invoking crypto\n    // https://github.com/getsentry/sentry-javascript/issues/8935\n  }\n\n  // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523\n  // Concatenating the following numbers as strings results in '10000000100040008000100000000000'\n  return (([1e7] as unknown as string) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, c =>\n    // eslint-disable-next-line no-bitwise\n    ((c as unknown as number) ^ ((getRandomByte() & 15) >> ((c as unknown as number) / 4))).toString(16),\n  );\n}\n\nfunction getFirstException(event: Event): Exception | undefined {\n  return event.exception && event.exception.values ? event.exception.values[0] : undefined;\n}\n\n/**\n * Extracts either message or type+value from an event that can be used for user-facing logs\n * @returns event's description\n */\nexport function getEventDescription(event: Event): string {\n  const { message, event_id: eventId } = event;\n  if (message) {\n    return message;\n  }\n\n  const firstException = getFirstException(event);\n  if (firstException) {\n    if (firstException.type && firstException.value) {\n      return `${firstException.type}: ${firstException.value}`;\n    }\n    return firstException.type || firstException.value || eventId || '<unknown>';\n  }\n  return eventId || '<unknown>';\n}\n\n/**\n * Adds exception values, type and value to an synthetic Exception.\n * @param event The event to modify.\n * @param value Value of the exception.\n * @param type Type of the exception.\n * @hidden\n */\nexport function addExceptionTypeValue(event: Event, value?: string, type?: string): void {\n  const exception = (event.exception = event.exception || {});\n  const values = (exception.values = exception.values || []);\n  const firstException = (values[0] = values[0] || {});\n  if (!firstException.value) {\n    firstException.value = value || '';\n  }\n  if (!firstException.type) {\n    firstException.type = type || 'Error';\n  }\n}\n\n/**\n * Adds exception mechanism data to a given event. Uses defaults if the second parameter is not passed.\n *\n * @param event The event to modify.\n * @param newMechanism Mechanism data to add to the event.\n * @hidden\n */\nexport function addExceptionMechanism(event: Event, newMechanism?: Partial<Mechanism>): void {\n  const firstException = getFirstException(event);\n  if (!firstException) {\n    return;\n  }\n\n  const defaultMechanism = { type: 'generic', handled: true };\n  const currentMechanism = firstException.mechanism;\n  firstException.mechanism = { ...defaultMechanism, ...currentMechanism, ...newMechanism };\n\n  if (newMechanism && 'data' in newMechanism) {\n    const mergedData = { ...(currentMechanism && currentMechanism.data), ...newMechanism.data };\n    firstException.mechanism.data = mergedData;\n  }\n}\n\n// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string\nconst SEMVER_REGEXP =\n  /^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-((?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\\+([0-9a-zA-Z-]+(?:\\.[0-9a-zA-Z-]+)*))?$/;\n\n/**\n * Represents Semantic Versioning object\n */\ninterface SemVer {\n  major?: number;\n  minor?: number;\n  patch?: number;\n  prerelease?: string;\n  buildmetadata?: string;\n}\n\n/**\n * Parses input into a SemVer interface\n * @param input string representation of a semver version\n */\nexport function parseSemver(input: string): SemVer {\n  const match = input.match(SEMVER_REGEXP) || [];\n  const major = parseInt(match[1], 10);\n  const minor = parseInt(match[2], 10);\n  const patch = parseInt(match[3], 10);\n  return {\n    buildmetadata: match[5],\n    major: isNaN(major) ? undefined : major,\n    minor: isNaN(minor) ? undefined : minor,\n    patch: isNaN(patch) ? undefined : patch,\n    prerelease: match[4],\n  };\n}\n\n/**\n * This function adds context (pre/post/line) lines to the provided frame\n *\n * @param lines string[] containing all lines\n * @param frame StackFrame that will be mutated\n * @param linesOfContext number of context lines we want to add pre/post\n */\nexport function addContextToFrame(lines: string[], frame: StackFrame, linesOfContext: number = 5): void {\n  // When there is no line number in the frame, attaching context is nonsensical and will even break grouping\n  if (frame.lineno === undefined) {\n    return;\n  }\n\n  const maxLines = lines.length;\n  const sourceLine = Math.max(Math.min(maxLines - 1, frame.lineno - 1), 0);\n\n  frame.pre_context = lines\n    .slice(Math.max(0, sourceLine - linesOfContext), sourceLine)\n    .map((line: string) => snipLine(line, 0));\n\n  frame.context_line = snipLine(lines[Math.min(maxLines - 1, sourceLine)], frame.colno || 0);\n\n  frame.post_context = lines\n    .slice(Math.min(sourceLine + 1, maxLines), sourceLine + 1 + linesOfContext)\n    .map((line: string) => snipLine(line, 0));\n}\n\n/**\n * Checks whether or not we've already captured the given exception (note: not an identical exception - the very object\n * in question), and marks it captured if not.\n *\n * This is useful because it's possible for an error to get captured by more than one mechanism. After we intercept and\n * record an error, we rethrow it (assuming we've intercepted it before it's reached the top-level global handlers), so\n * that we don't interfere with whatever effects the error might have had were the SDK not there. At that point, because\n * the error has been rethrown, it's possible for it to bubble up to some other code we've instrumented. If it's not\n * caught after that, it will bubble all the way up to the global handlers (which of course we also instrument). This\n * function helps us ensure that even if we encounter the same error more than once, we only record it the first time we\n * see it.\n *\n * Note: It will ignore primitives (always return `false` and not mark them as seen), as properties can't be set on\n * them. {@link: Object.objectify} can be used on exceptions to convert any that are primitives into their equivalent\n * object wrapper forms so that this check will always work. However, because we need to flag the exact object which\n * will get rethrown, and because that rethrowing happens outside of the event processing pipeline, the objectification\n * must be done before the exception captured.\n *\n * @param A thrown exception to check or flag as having been seen\n * @returns `true` if the exception has already been captured, `false` if not (with the side effect of marking it seen)\n */\nexport function checkOrSetAlreadyCaught(exception: unknown): boolean {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  if (exception && (exception as any).__sentry_captured__) {\n    return true;\n  }\n\n  try {\n    // set it this way rather than by assignment so that it's not ennumerable and therefore isn't recorded by the\n    // `ExtraErrorData` integration\n    addNonEnumerableProperty(exception as { [key: string]: unknown }, '__sentry_captured__', true);\n  } catch (err) {\n    // `exception` is a primitive, so we can't mark it seen\n  }\n\n  return false;\n}\n\n/**\n * Checks whether the given input is already an array, and if it isn't, wraps it in one.\n *\n * @param maybeArray Input to turn into an array, if necessary\n * @returns The input, if already an array, or an array with the input as the only element, if not\n */\nexport function arrayify<T = unknown>(maybeArray: T | T[]): T[] {\n  return Array.isArray(maybeArray) ? maybeArray : [maybeArray];\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n\nimport type { HandlerDataUnhandledRejection } from '@sentry/types';\n\nimport { GLOBAL_OBJ } from '../worldwide';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers';\n\nlet _oldOnUnhandledRejectionHandler: (typeof GLOBAL_OBJ)['onunhandledrejection'] | null = null;\n\n/**\n * Add an instrumentation handler for when an unhandled promise rejection is captured.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addGlobalUnhandledRejectionInstrumentationHandler(\n  handler: (data: HandlerDataUnhandledRejection) => void,\n): void {\n  const type = 'unhandledrejection';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentUnhandledRejection);\n}\n\nfunction instrumentUnhandledRejection(): void {\n  _oldOnUnhandledRejectionHandler = GLOBAL_OBJ.onunhandledrejection;\n\n  GLOBAL_OBJ.onunhandledrejection = function (e: any): boolean {\n    const handlerData: HandlerDataUnhandledRejection = e;\n    triggerHandlers('unhandledrejection', handlerData);\n\n    if (_oldOnUnhandledRejectionHandler && !_oldOnUnhandledRejectionHandler.__SENTRY_LOADER__) {\n      // eslint-disable-next-line prefer-rest-params\n      return _oldOnUnhandledRejectionHandler.apply(this, arguments);\n    }\n\n    return true;\n  };\n\n  GLOBAL_OBJ.onunhandledrejection.__SENTRY_INSTRUMENTED__ = true;\n}\n","import type { browserTracingIntegration } from '@sentry-internal/tracing';\nimport { BrowserTracing } from '@sentry-internal/tracing';\nimport { captureException, withScope } from '@sentry/core';\nimport type { DsnLike, Integration, Mechanism, WrappedFunction } from '@sentry/types';\nimport {\n  GLOBAL_OBJ,\n  addExceptionMechanism,\n  addExceptionTypeValue,\n  addNonEnumerableProperty,\n  getOriginalFunction,\n  markFunctionWrapped,\n} from '@sentry/utils';\n\nexport const WINDOW = GLOBAL_OBJ as typeof GLOBAL_OBJ & Window;\n\nlet ignoreOnError: number = 0;\n\n/**\n * @hidden\n */\nexport function shouldIgnoreOnError(): boolean {\n  return ignoreOnError > 0;\n}\n\n/**\n * @hidden\n */\nexport function ignoreNextOnError(): void {\n  // onerror should trigger before setTimeout\n  ignoreOnError++;\n  setTimeout(() => {\n    ignoreOnError--;\n  });\n}\n\n/**\n * Instruments the given function and sends an event to Sentry every time the\n * function throws an exception.\n *\n * @param fn A function to wrap. It is generally safe to pass an unbound function, because the returned wrapper always\n * has a correct `this` context.\n * @returns The wrapped function.\n * @hidden\n */\nexport function wrap(\n  fn: WrappedFunction,\n  options: {\n    mechanism?: Mechanism;\n  } = {},\n  before?: WrappedFunction,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n): any {\n  // for future readers what this does is wrap a function and then create\n  // a bi-directional wrapping between them.\n  //\n  // example: wrapped = wrap(original);\n  //  original.__sentry_wrapped__ -> wrapped\n  //  wrapped.__sentry_original__ -> original\n\n  if (typeof fn !== 'function') {\n    return fn;\n  }\n\n  try {\n    // if we're dealing with a function that was previously wrapped, return\n    // the original wrapper.\n    const wrapper = fn.__sentry_wrapped__;\n    if (wrapper) {\n      if (typeof wrapper === 'function') {\n        return wrapper;\n      } else {\n        // If we find that the `__sentry_wrapped__` function is not a function at the time of accessing it, it means\n        // that something messed with it. In that case we want to return the originally passed function.\n        return fn;\n      }\n    }\n\n    // We don't wanna wrap it twice\n    if (getOriginalFunction(fn)) {\n      return fn;\n    }\n  } catch (e) {\n    // Just accessing custom props in some Selenium environments\n    // can cause a \"Permission denied\" exception (see raven-js#495).\n    // Bail on wrapping and return the function as-is (defers to window.onerror).\n    return fn;\n  }\n\n  /* eslint-disable prefer-rest-params */\n  // It is important that `sentryWrapped` is not an arrow function to preserve the context of `this`\n  const sentryWrapped: WrappedFunction = function (this: unknown): void {\n    const args = Array.prototype.slice.call(arguments);\n\n    try {\n      if (before && typeof before === 'function') {\n        before.apply(this, arguments);\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access\n      const wrappedArguments = args.map((arg: any) => wrap(arg, options));\n\n      // Attempt to invoke user-land function\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame, it\n      //       means the sentry.javascript SDK caught an error invoking your application code. This\n      //       is expected behavior and NOT indicative of a bug with sentry.javascript.\n      return fn.apply(this, wrappedArguments);\n    } catch (ex) {\n      ignoreNextOnError();\n\n      withScope(scope => {\n        scope.addEventProcessor(event => {\n          if (options.mechanism) {\n            addExceptionTypeValue(event, undefined, undefined);\n            addExceptionMechanism(event, options.mechanism);\n          }\n\n          event.extra = {\n            ...event.extra,\n            arguments: args,\n          };\n\n          return event;\n        });\n\n        captureException(ex);\n      });\n\n      throw ex;\n    }\n  };\n  /* eslint-enable prefer-rest-params */\n\n  // Accessing some objects may throw\n  // ref: https://github.com/getsentry/sentry-javascript/issues/1168\n  try {\n    for (const property in fn) {\n      if (Object.prototype.hasOwnProperty.call(fn, property)) {\n        sentryWrapped[property] = fn[property];\n      }\n    }\n  } catch (_oO) {} // eslint-disable-line no-empty\n\n  // Signal that this function has been wrapped/filled already\n  // for both debugging and to prevent it to being wrapped/filled twice\n  markFunctionWrapped(sentryWrapped, fn);\n\n  addNonEnumerableProperty(fn, '__sentry_wrapped__', sentryWrapped);\n\n  // Restore original function name (not all browsers allow that)\n  try {\n    const descriptor = Object.getOwnPropertyDescriptor(sentryWrapped, 'name') as PropertyDescriptor;\n    if (descriptor.configurable) {\n      Object.defineProperty(sentryWrapped, 'name', {\n        get(): string {\n          return fn.name;\n        },\n      });\n    }\n    // eslint-disable-next-line no-empty\n  } catch (_oO) {}\n\n  return sentryWrapped;\n}\n\n/**\n * All properties the report dialog supports\n *\n * @deprecated This type will be removed in the next major version of the Sentry SDK. `showReportDialog` will still be around, however the `eventId` option will now be required.\n */\nexport interface ReportDialogOptions {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  [key: string]: any;\n  eventId?: string;\n  dsn?: DsnLike;\n  user?: {\n    email?: string;\n    name?: string;\n  };\n  lang?: string;\n  title?: string;\n  subtitle?: string;\n  subtitle2?: string;\n  labelName?: string;\n  labelEmail?: string;\n  labelComments?: string;\n  labelClose?: string;\n  labelSubmit?: string;\n  errorGeneric?: string;\n  errorFormEntry?: string;\n  successMessage?: string;\n  /** Callback after reportDialog showed up */\n  onLoad?(this: void): void;\n  /** Callback after reportDialog closed */\n  onClose?(this: void): void;\n}\n\n/**\n * This is a slim shim of `browserTracingIntegration` for the CDN bundles.\n * Since the actual functional integration uses a different code from `BrowserTracing`,\n * we want to avoid shipping both of them in the CDN bundles, as that would blow up the size.\n * Instead, we provide a functional integration with the same API, but the old implementation.\n * This means that it's not possible to register custom routing instrumentation, but that's OK for now.\n * We also don't expose the utilities for this anyhow in the CDN bundles.\n * For users that need custom routing in CDN bundles, they have to continue using `new BrowserTracing()` until v8.\n */\nexport function bundleBrowserTracingIntegration(\n  options: Parameters<typeof browserTracingIntegration>[0] = {},\n): Integration {\n  // Migrate some options from the old integration to the new one\n  // eslint-disable-next-line deprecation/deprecation\n  const opts: ConstructorParameters<typeof BrowserTracing>[0] = options;\n\n  if (typeof options.markBackgroundSpan === 'boolean') {\n    opts.markBackgroundTransactions = options.markBackgroundSpan;\n  }\n\n  if (typeof options.instrumentPageLoad === 'boolean') {\n    opts.startTransactionOnPageLoad = options.instrumentPageLoad;\n  }\n\n  if (typeof options.instrumentNavigation === 'boolean') {\n    opts.startTransactionOnLocationChange = options.instrumentNavigation;\n  }\n\n  // eslint-disable-next-line deprecation/deprecation\n  return new BrowserTracing(opts);\n}\n","import { convertIntegrationFnToClass, defineIntegration } from '@sentry/core';\nimport type { Event, Exception, Integration, IntegrationClass, IntegrationFn, StackFrame } from '@sentry/types';\nimport { logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../debug-build';\n\nconst INTEGRATION_NAME = 'Dedupe';\n\nconst _dedupeIntegration = (() => {\n  let previousEvent: Event | undefined;\n\n  return {\n    name: INTEGRATION_NAME,\n    // TODO v8: Remove this\n    setupOnce() {}, // eslint-disable-line @typescript-eslint/no-empty-function\n    processEvent(currentEvent) {\n      // We want to ignore any non-error type events, e.g. transactions or replays\n      // These should never be deduped, and also not be compared against as _previousEvent.\n      if (currentEvent.type) {\n        return currentEvent;\n      }\n\n      // Juuust in case something goes wrong\n      try {\n        if (_shouldDropEvent(currentEvent, previousEvent)) {\n          DEBUG_BUILD && logger.warn('Event dropped due to being a duplicate of previously captured event.');\n          return null;\n        }\n      } catch (_oO) {} // eslint-disable-line no-empty\n\n      return (previousEvent = currentEvent);\n    },\n  };\n}) satisfies IntegrationFn;\n\nexport const dedupeIntegration = defineIntegration(_dedupeIntegration);\n\n/**\n * Deduplication filter.\n * @deprecated Use `dedupeIntegration()` instead.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport const Dedupe = convertIntegrationFnToClass(INTEGRATION_NAME, dedupeIntegration) as IntegrationClass<\n  Integration & { processEvent: (event: Event) => Event }\n>;\n\nfunction _shouldDropEvent(currentEvent: Event, previousEvent?: Event): boolean {\n  if (!previousEvent) {\n    return false;\n  }\n\n  if (_isSameMessageEvent(currentEvent, previousEvent)) {\n    return true;\n  }\n\n  if (_isSameExceptionEvent(currentEvent, previousEvent)) {\n    return true;\n  }\n\n  return false;\n}\n\nfunction _isSameMessageEvent(currentEvent: Event, previousEvent: Event): boolean {\n  const currentMessage = currentEvent.message;\n  const previousMessage = previousEvent.message;\n\n  // If neither event has a message property, they were both exceptions, so bail out\n  if (!currentMessage && !previousMessage) {\n    return false;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentMessage && !previousMessage) || (!currentMessage && previousMessage)) {\n    return false;\n  }\n\n  if (currentMessage !== previousMessage) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\nfunction _isSameExceptionEvent(currentEvent: Event, previousEvent: Event): boolean {\n  const previousException = _getExceptionFromEvent(previousEvent);\n  const currentException = _getExceptionFromEvent(currentEvent);\n\n  if (!previousException || !currentException) {\n    return false;\n  }\n\n  if (previousException.type !== currentException.type || previousException.value !== currentException.value) {\n    return false;\n  }\n\n  if (!_isSameFingerprint(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  if (!_isSameStacktrace(currentEvent, previousEvent)) {\n    return false;\n  }\n\n  return true;\n}\n\nfunction _isSameStacktrace(currentEvent: Event, previousEvent: Event): boolean {\n  let currentFrames = _getFramesFromEvent(currentEvent);\n  let previousFrames = _getFramesFromEvent(previousEvent);\n\n  // If neither event has a stacktrace, they are assumed to be the same\n  if (!currentFrames && !previousFrames) {\n    return true;\n  }\n\n  // If only one event has a stacktrace, but not the other one, they are not the same\n  if ((currentFrames && !previousFrames) || (!currentFrames && previousFrames)) {\n    return false;\n  }\n\n  currentFrames = currentFrames as StackFrame[];\n  previousFrames = previousFrames as StackFrame[];\n\n  // If number of frames differ, they are not the same\n  if (previousFrames.length !== currentFrames.length) {\n    return false;\n  }\n\n  // Otherwise, compare the two\n  for (let i = 0; i < previousFrames.length; i++) {\n    const frameA = previousFrames[i];\n    const frameB = currentFrames[i];\n\n    if (\n      frameA.filename !== frameB.filename ||\n      frameA.lineno !== frameB.lineno ||\n      frameA.colno !== frameB.colno ||\n      frameA.function !== frameB.function\n    ) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction _isSameFingerprint(currentEvent: Event, previousEvent: Event): boolean {\n  let currentFingerprint = currentEvent.fingerprint;\n  let previousFingerprint = previousEvent.fingerprint;\n\n  // If neither event has a fingerprint, they are assumed to be the same\n  if (!currentFingerprint && !previousFingerprint) {\n    return true;\n  }\n\n  // If only one event has a fingerprint, but not the other one, they are not the same\n  if ((currentFingerprint && !previousFingerprint) || (!currentFingerprint && previousFingerprint)) {\n    return false;\n  }\n\n  currentFingerprint = currentFingerprint as string[];\n  previousFingerprint = previousFingerprint as string[];\n\n  // Otherwise, compare the two\n  try {\n    return !!(currentFingerprint.join('') === previousFingerprint.join(''));\n  } catch (_oO) {\n    return false;\n  }\n}\n\nfunction _getExceptionFromEvent(event: Event): Exception | undefined {\n  return event.exception && event.exception.values && event.exception.values[0];\n}\n\nfunction _getFramesFromEvent(event: Event): StackFrame[] | undefined {\n  const exception = event.exception;\n\n  if (exception) {\n    try {\n      // @ts-expect-error Object could be undefined\n      return exception.values[0].stacktrace.frames;\n    } catch (_oO) {\n      return undefined;\n    }\n  }\n  return undefined;\n}\n","import { DEBUG_BUILD } from '../debug-build';\nimport { logger } from '../logger';\nimport { getFunctionName } from '../stacktrace';\n\nexport type InstrumentHandlerType = 'console' | 'dom' | 'fetch' | 'history' | 'xhr' | 'error' | 'unhandledrejection';\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type InstrumentHandlerCallback = (data: any) => void;\n\n// We keep the handlers globally\nconst handlers: { [key in InstrumentHandlerType]?: InstrumentHandlerCallback[] } = {};\nconst instrumented: { [key in InstrumentHandlerType]?: boolean } = {};\n\n/** Add a handler function. */\nexport function addHandler(type: InstrumentHandlerType, handler: InstrumentHandlerCallback): void {\n  handlers[type] = handlers[type] || [];\n  (handlers[type] as InstrumentHandlerCallback[]).push(handler);\n}\n\n/**\n * Reset all instrumentation handlers.\n * This can be used by tests to ensure we have a clean slate of instrumentation handlers.\n */\nexport function resetInstrumentationHandlers(): void {\n  Object.keys(handlers).forEach(key => {\n    handlers[key as InstrumentHandlerType] = undefined;\n  });\n}\n\n/** Maybe run an instrumentation function, unless it was already called. */\nexport function maybeInstrument(type: InstrumentHandlerType, instrumentFn: () => void): void {\n  if (!instrumented[type]) {\n    instrumentFn();\n    instrumented[type] = true;\n  }\n}\n\n/** Trigger handlers for a given instrumentation type. */\nexport function triggerHandlers(type: InstrumentHandlerType, data: unknown): void {\n  const typeHandlers = type && handlers[type];\n  if (!typeHandlers) {\n    return;\n  }\n\n  for (const handler of typeHandlers) {\n    try {\n      handler(data);\n    } catch (e) {\n      DEBUG_BUILD &&\n        logger.error(\n          `Error while triggering instrumentation handler.\\nType: ${type}\\nName: ${getFunctionName(handler)}\\nError:`,\n          e,\n        );\n    }\n  }\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\n\nimport type { ParameterizedString, PolymorphicEvent, Primitive } from '@sentry/types';\n\n// eslint-disable-next-line @typescript-eslint/unbound-method\nconst objectToString = Object.prototype.toString;\n\n/**\n * Checks whether given value's type is one of a few Error or Error-like\n * {@link isError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isError(wat: unknown): wat is Error {\n  switch (objectToString.call(wat)) {\n    case '[object Error]':\n    case '[object Exception]':\n    case '[object DOMException]':\n      return true;\n    default:\n      return isInstanceOf(wat, Error);\n  }\n}\n/**\n * Checks whether given value is an instance of the given built-in class.\n *\n * @param wat The value to be checked\n * @param className\n * @returns A boolean representing the result.\n */\nfunction isBuiltin(wat: unknown, className: string): boolean {\n  return objectToString.call(wat) === `[object ${className}]`;\n}\n\n/**\n * Checks whether given value's type is ErrorEvent\n * {@link isErrorEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isErrorEvent(wat: unknown): boolean {\n  return isBuiltin(wat, 'ErrorEvent');\n}\n\n/**\n * Checks whether given value's type is DOMError\n * {@link isDOMError}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMError(wat: unknown): boolean {\n  return isBuiltin(wat, 'DOMError');\n}\n\n/**\n * Checks whether given value's type is DOMException\n * {@link isDOMException}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isDOMException(wat: unknown): boolean {\n  return isBuiltin(wat, 'DOMException');\n}\n\n/**\n * Checks whether given value's type is a string\n * {@link isString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isString(wat: unknown): wat is string {\n  return isBuiltin(wat, 'String');\n}\n\n/**\n * Checks whether given string is parameterized\n * {@link isParameterizedString}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isParameterizedString(wat: unknown): wat is ParameterizedString {\n  return (\n    typeof wat === 'object' &&\n    wat !== null &&\n    '__sentry_template_string__' in wat &&\n    '__sentry_template_values__' in wat\n  );\n}\n\n/**\n * Checks whether given value is a primitive (undefined, null, number, boolean, string, bigint, symbol)\n * {@link isPrimitive}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPrimitive(wat: unknown): wat is Primitive {\n  return wat === null || isParameterizedString(wat) || (typeof wat !== 'object' && typeof wat !== 'function');\n}\n\n/**\n * Checks whether given value's type is an object literal, or a class instance.\n * {@link isPlainObject}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isPlainObject(wat: unknown): wat is Record<string, unknown> {\n  return isBuiltin(wat, 'Object');\n}\n\n/**\n * Checks whether given value's type is an Event instance\n * {@link isEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isEvent(wat: unknown): wat is PolymorphicEvent {\n  return typeof Event !== 'undefined' && isInstanceOf(wat, Event);\n}\n\n/**\n * Checks whether given value's type is an Element instance\n * {@link isElement}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isElement(wat: unknown): boolean {\n  return typeof Element !== 'undefined' && isInstanceOf(wat, Element);\n}\n\n/**\n * Checks whether given value's type is an regexp\n * {@link isRegExp}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isRegExp(wat: unknown): wat is RegExp {\n  return isBuiltin(wat, 'RegExp');\n}\n\n/**\n * Checks whether given value has a then function.\n * @param wat A value to be checked.\n */\nexport function isThenable(wat: any): wat is PromiseLike<any> {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n  return Boolean(wat && wat.then && typeof wat.then === 'function');\n}\n\n/**\n * Checks whether given value's type is a SyntheticEvent\n * {@link isSyntheticEvent}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isSyntheticEvent(wat: unknown): boolean {\n  return isPlainObject(wat) && 'nativeEvent' in wat && 'preventDefault' in wat && 'stopPropagation' in wat;\n}\n\n/**\n * Checks whether given value is NaN\n * {@link isNaN}.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isNaN(wat: unknown): boolean {\n  return typeof wat === 'number' && wat !== wat;\n}\n\n/**\n * Checks whether given value's type is an instance of provided constructor.\n * {@link isInstanceOf}.\n *\n * @param wat A value to be checked.\n * @param base A constructor to be used in a check.\n * @returns A boolean representing the result.\n */\nexport function isInstanceOf(wat: any, base: any): boolean {\n  try {\n    return wat instanceof base;\n  } catch (_e) {\n    return false;\n  }\n}\n\ninterface VueViewModel {\n  // Vue3\n  __isVue?: boolean;\n  // Vue2\n  _isVue?: boolean;\n}\n/**\n * Checks whether given value's type is a Vue ViewModel.\n *\n * @param wat A value to be checked.\n * @returns A boolean representing the result.\n */\nexport function isVueViewModel(wat: unknown): boolean {\n  // Not using Object.prototype.toString because in Vue 3 it would read the instance's Symbol(Symbol.toStringTag) property.\n  return !!(typeof wat === 'object' && wat !== null && ((wat as VueViewModel).__isVue || (wat as VueViewModel)._isVue));\n}\n","import type { Primitive } from '@sentry/types';\n\nimport { isNaN, isSyntheticEvent, isVueViewModel } from './is';\nimport type { MemoFunc } from './memo';\nimport { memoBuilder } from './memo';\nimport { convertToPlainObject } from './object';\nimport { getFunctionName } from './stacktrace';\n\ntype Prototype = { constructor: (...args: unknown[]) => unknown };\n// This is a hack to placate TS, relying on the fact that technically, arrays are objects with integer keys. Normally we\n// think of those keys as actual numbers, but `arr['0']` turns out to work just as well as `arr[0]`, and doing it this\n// way lets us use a single type in the places where behave as if we are only dealing with objects, even if some of them\n// might be arrays.\ntype ObjOrArray<T> = { [key: string]: T };\n\n/**\n * Recursively normalizes the given object.\n *\n * - Creates a copy to prevent original input mutation\n * - Skips non-enumerable properties\n * - When stringifying, calls `toJSON` if implemented\n * - Removes circular references\n * - Translates non-serializable values (`undefined`/`NaN`/functions) to serializable format\n * - Translates known global objects/classes to a string representations\n * - Takes care of `Error` object serialization\n * - Optionally limits depth of final output\n * - Optionally limits number of properties/elements included in any single object/array\n *\n * @param input The object to be normalized.\n * @param depth The max depth to which to normalize the object. (Anything deeper stringified whole.)\n * @param maxProperties The max number of elements or properties to be included in any single array or\n * object in the normallized output.\n * @returns A normalized version of the object, or `\"**non-serializable**\"` if any errors are thrown during normalization.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function normalize(input: unknown, depth: number = 100, maxProperties: number = +Infinity): any {\n  try {\n    // since we're at the outermost level, we don't provide a key\n    return visit('', input, depth, maxProperties);\n  } catch (err) {\n    return { ERROR: `**non-serializable** (${err})` };\n  }\n}\n\n/** JSDoc */\nexport function normalizeToSize<T>(\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  object: { [key: string]: any },\n  // Default Node.js REPL depth\n  depth: number = 3,\n  // 100kB, as 200kB is max payload size, so half sounds reasonable\n  maxSize: number = 100 * 1024,\n): T {\n  const normalized = normalize(object, depth);\n\n  if (jsonSize(normalized) > maxSize) {\n    return normalizeToSize(object, depth - 1, maxSize);\n  }\n\n  return normalized as T;\n}\n\n/**\n * Visits a node to perform normalization on it\n *\n * @param key The key corresponding to the given node\n * @param value The node to be visited\n * @param depth Optional number indicating the maximum recursion depth\n * @param maxProperties Optional maximum number of properties/elements included in any single object/array\n * @param memo Optional Memo class handling decycling\n */\nfunction visit(\n  key: string,\n  value: unknown,\n  depth: number = +Infinity,\n  maxProperties: number = +Infinity,\n  memo: MemoFunc = memoBuilder(),\n): Primitive | ObjOrArray<unknown> {\n  const [memoize, unmemoize] = memo;\n\n  // Get the simple cases out of the way first\n  if (\n    value == null || // this matches null and undefined -> eqeq not eqeqeq\n    (['number', 'boolean', 'string'].includes(typeof value) && !isNaN(value))\n  ) {\n    return value as Primitive;\n  }\n\n  const stringified = stringifyValue(key, value);\n\n  // Anything we could potentially dig into more (objects or arrays) will have come back as `\"[object XXXX]\"`.\n  // Everything else will have already been serialized, so if we don't see that pattern, we're done.\n  if (!stringified.startsWith('[object ')) {\n    return stringified;\n  }\n\n  // From here on, we can assert that `value` is either an object or an array.\n\n  // Do not normalize objects that we know have already been normalized. As a general rule, the\n  // \"__sentry_skip_normalization__\" property should only be used sparingly and only should only be set on objects that\n  // have already been normalized.\n  if ((value as ObjOrArray<unknown>)['__sentry_skip_normalization__']) {\n    return value as ObjOrArray<unknown>;\n  }\n\n  // We can set `__sentry_override_normalization_depth__` on an object to ensure that from there\n  // We keep a certain amount of depth.\n  // This should be used sparingly, e.g. we use it for the redux integration to ensure we get a certain amount of state.\n  const remainingDepth =\n    typeof (value as ObjOrArray<unknown>)['__sentry_override_normalization_depth__'] === 'number'\n      ? ((value as ObjOrArray<unknown>)['__sentry_override_normalization_depth__'] as number)\n      : depth;\n\n  // We're also done if we've reached the max depth\n  if (remainingDepth === 0) {\n    // At this point we know `serialized` is a string of the form `\"[object XXXX]\"`. Clean it up so it's just `\"[XXXX]\"`.\n    return stringified.replace('object ', '');\n  }\n\n  // If we've already visited this branch, bail out, as it's circular reference. If not, note that we're seeing it now.\n  if (memoize(value)) {\n    return '[Circular ~]';\n  }\n\n  // If the value has a `toJSON` method, we call it to extract more information\n  const valueWithToJSON = value as unknown & { toJSON?: () => unknown };\n  if (valueWithToJSON && typeof valueWithToJSON.toJSON === 'function') {\n    try {\n      const jsonValue = valueWithToJSON.toJSON();\n      // We need to normalize the return value of `.toJSON()` in case it has circular references\n      return visit('', jsonValue, remainingDepth - 1, maxProperties, memo);\n    } catch (err) {\n      // pass (The built-in `toJSON` failed, but we can still try to do it ourselves)\n    }\n  }\n\n  // At this point we know we either have an object or an array, we haven't seen it before, and we're going to recurse\n  // because we haven't yet reached the max depth. Create an accumulator to hold the results of visiting each\n  // property/entry, and keep track of the number of items we add to it.\n  const normalized = (Array.isArray(value) ? [] : {}) as ObjOrArray<unknown>;\n  let numAdded = 0;\n\n  // Before we begin, convert`Error` and`Event` instances into plain objects, since some of each of their relevant\n  // properties are non-enumerable and otherwise would get missed.\n  const visitable = convertToPlainObject(value as ObjOrArray<unknown>);\n\n  for (const visitKey in visitable) {\n    // Avoid iterating over fields in the prototype if they've somehow been exposed to enumeration.\n    if (!Object.prototype.hasOwnProperty.call(visitable, visitKey)) {\n      continue;\n    }\n\n    if (numAdded >= maxProperties) {\n      normalized[visitKey] = '[MaxProperties ~]';\n      break;\n    }\n\n    // Recursively visit all the child nodes\n    const visitValue = visitable[visitKey];\n    normalized[visitKey] = visit(visitKey, visitValue, remainingDepth - 1, maxProperties, memo);\n\n    numAdded++;\n  }\n\n  // Once we've visited all the branches, remove the parent from memo storage\n  unmemoize(value);\n\n  // Return accumulated values\n  return normalized;\n}\n\n/**\n * @deprecated This export will be removed in v8.\n */\nexport { visit as walk };\n\n/* eslint-disable complexity */\n/**\n * Stringify the given value. Handles various known special values and types.\n *\n * Not meant to be used on simple primitives which already have a string representation, as it will, for example, turn\n * the number 1231 into \"[Object Number]\", nor on `null`, as it will throw.\n *\n * @param value The value to stringify\n * @returns A stringified representation of the given value\n */\nfunction stringifyValue(\n  key: unknown,\n  // this type is a tiny bit of a cheat, since this function does handle NaN (which is technically a number), but for\n  // our internal use, it'll do\n  value: Exclude<unknown, string | number | boolean | null>,\n): string {\n  try {\n    if (key === 'domain' && value && typeof value === 'object' && (value as { _events: unknown })._events) {\n      return '[Domain]';\n    }\n\n    if (key === 'domainEmitter') {\n      return '[DomainEmitter]';\n    }\n\n    // It's safe to use `global`, `window`, and `document` here in this manner, as we are asserting using `typeof` first\n    // which won't throw if they are not present.\n\n    if (typeof global !== 'undefined' && value === global) {\n      return '[Global]';\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    if (typeof window !== 'undefined' && value === window) {\n      return '[Window]';\n    }\n\n    // eslint-disable-next-line no-restricted-globals\n    if (typeof document !== 'undefined' && value === document) {\n      return '[Document]';\n    }\n\n    if (isVueViewModel(value)) {\n      return '[VueViewModel]';\n    }\n\n    // React's SyntheticEvent thingy\n    if (isSyntheticEvent(value)) {\n      return '[SyntheticEvent]';\n    }\n\n    if (typeof value === 'number' && value !== value) {\n      return '[NaN]';\n    }\n\n    if (typeof value === 'function') {\n      return `[Function: ${getFunctionName(value)}]`;\n    }\n\n    if (typeof value === 'symbol') {\n      return `[${String(value)}]`;\n    }\n\n    // stringified BigInts are indistinguishable from regular numbers, so we need to label them to avoid confusion\n    if (typeof value === 'bigint') {\n      return `[BigInt: ${String(value)}]`;\n    }\n\n    // Now that we've knocked out all the special cases and the primitives, all we have left are objects. Simply casting\n    // them to strings means that instances of classes which haven't defined their `toStringTag` will just come out as\n    // `\"[object Object]\"`. If we instead look at the constructor's name (which is the same as the name of the class),\n    // we can make sure that only plain objects come out that way.\n    const objName = getConstructorName(value);\n\n    // Handle HTML Elements\n    if (/^HTML(\\w*)Element$/.test(objName)) {\n      return `[HTMLElement: ${objName}]`;\n    }\n\n    return `[object ${objName}]`;\n  } catch (err) {\n    return `**non-serializable** (${err})`;\n  }\n}\n/* eslint-enable complexity */\n\nfunction getConstructorName(value: unknown): string {\n  const prototype: Prototype | null = Object.getPrototypeOf(value);\n\n  return prototype ? prototype.constructor.name : 'null prototype';\n}\n\n/** Calculates bytes size of input string */\nfunction utf8Length(value: string): number {\n  // eslint-disable-next-line no-bitwise\n  return ~-encodeURI(value).split(/%..|./).length;\n}\n\n/** Calculates bytes size of input object */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction jsonSize(value: any): number {\n  return utf8Length(JSON.stringify(value));\n}\n\n/**\n * Normalizes URLs in exceptions and stacktraces to a base path so Sentry can fingerprint\n * across platforms and working directory.\n *\n * @param url The URL to be normalized.\n * @param basePath The application base path.\n * @returns The normalized URL.\n */\nexport function normalizeUrlToBase(url: string, basePath: string): string {\n  const escapedBase = basePath\n    // Backslash to forward\n    .replace(/\\\\/g, '/')\n    // Escape RegExp special characters\n    .replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&');\n\n  let newUrl = url;\n  try {\n    newUrl = decodeURI(url);\n  } catch (_Oo) {\n    // Sometime this breaks\n  }\n  return (\n    newUrl\n      .replace(/\\\\/g, '/')\n      .replace(/webpack:\\/?/g, '') // Remove intermediate base path\n      // eslint-disable-next-line @sentry-internal/sdk/no-regexp-constructor\n      .replace(new RegExp(`(file://)?/*${escapedBase}/*`, 'ig'), 'app:///')\n  );\n}\n","/* eslint-disable @typescript-eslint/no-unsafe-member-access */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n\nexport type MemoFunc = [\n  // memoize\n  (obj: any) => boolean,\n  // unmemoize\n  (obj: any) => void,\n];\n\n/**\n * Helper to decycle json objects\n */\nexport function memoBuilder(): MemoFunc {\n  const hasWeakSet = typeof WeakSet === 'function';\n  const inner: any = hasWeakSet ? new WeakSet() : [];\n  function memoize(obj: any): boolean {\n    if (hasWeakSet) {\n      if (inner.has(obj)) {\n        return true;\n      }\n      inner.add(obj);\n      return false;\n    }\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (let i = 0; i < inner.length; i++) {\n      const value = inner[i];\n      if (value === obj) {\n        return true;\n      }\n    }\n    inner.push(obj);\n    return false;\n  }\n\n  function unmemoize(obj: any): void {\n    if (hasWeakSet) {\n      inner.delete(obj);\n    } else {\n      for (let i = 0; i < inner.length; i++) {\n        if (inner[i] === obj) {\n          inner.splice(i, 1);\n          break;\n        }\n      }\n    }\n  }\n  return [memoize, unmemoize];\n}\n","import { convertIntegrationFnToClass, defineIntegration } from '@sentry/core';\nimport type { Client, Event, EventHint, Integration, IntegrationClass, IntegrationFn } from '@sentry/types';\nimport { applyAggregateErrorsToEvent } from '@sentry/utils';\nimport { exceptionFromError } from '../eventbuilder';\n\ninterface LinkedErrorsOptions {\n  key?: string;\n  limit?: number;\n}\n\nconst DEFAULT_KEY = 'cause';\nconst DEFAULT_LIMIT = 5;\n\nconst INTEGRATION_NAME = 'LinkedErrors';\n\nconst _linkedErrorsIntegration = ((options: LinkedErrorsOptions = {}) => {\n  const limit = options.limit || DEFAULT_LIMIT;\n  const key = options.key || DEFAULT_KEY;\n\n  return {\n    name: INTEGRATION_NAME,\n    // TODO v8: Remove this\n    setupOnce() {}, // eslint-disable-line @typescript-eslint/no-empty-function\n    preprocessEvent(event, hint, client) {\n      const options = client.getOptions();\n\n      applyAggregateErrorsToEvent(\n        // This differs from the LinkedErrors integration in core by using a different exceptionFromError function\n        exceptionFromError,\n        options.stackParser,\n        options.maxValueLength,\n        key,\n        limit,\n        event,\n        hint,\n      );\n    },\n  };\n}) satisfies IntegrationFn;\n\nexport const linkedErrorsIntegration = defineIntegration(_linkedErrorsIntegration);\n\n/**\n * Aggregrate linked errors in an event.\n * @deprecated Use `linkedErrorsIntegration()` instead.\n */\n// eslint-disable-next-line deprecation/deprecation\nexport const LinkedErrors = convertIntegrationFnToClass(INTEGRATION_NAME, linkedErrorsIntegration) as IntegrationClass<\n  Integration & { preprocessEvent: (event: Event, hint: EventHint, client: Client) => void }\n> & { new (options?: { key?: string; limit?: number }): Integration };\n","/*\n * This module exists for optimizations in the build process through rollup and terser.  We define some global\n * constants, which can be overridden during build. By guarding certain pieces of code with functions that return these\n * constants, we can control whether or not they appear in the final bundle. (Any code guarded by a false condition will\n * never run, and will hence be dropped during treeshaking.) The two primary uses for this are stripping out calls to\n * `logger` and preventing node-related code from appearing in browser bundles.\n *\n * Attention:\n * This file should not be used to define constants/flags that are intended to be used for tree-shaking conducted by\n * users. These flags should live in their respective packages, as we identified user tooling (specifically webpack)\n * having issues tree-shaking these constants across package boundaries.\n * An example for this is the __SENTRY_DEBUG__ constant. It is declared in each package individually because we want\n * users to be able to shake away expressions that it guards.\n */\n\ndeclare const __SENTRY_BROWSER_BUNDLE__: boolean | undefined;\n\nexport type SdkSource = 'npm' | 'cdn' | 'loader';\n\n/**\n * Figures out if we're building a browser bundle.\n *\n * @returns true if this is a browser bundle build.\n */\nexport function isBrowserBundle(): boolean {\n  return typeof __SENTRY_BROWSER_BUNDLE__ !== 'undefined' && !!__SENTRY_BROWSER_BUNDLE__;\n}\n\n/**\n * Get source of SDK.\n */\nexport function getSDKSource(): SdkSource {\n  // @ts-expect-error __SENTRY_SDK_SOURCE__ is injected by rollup during build process\n  return __SENTRY_SDK_SOURCE__;\n}\n","/* eslint-disable max-lines */\nimport type { SpanTimeInput, TransactionContext } from '@sentry/types';\nimport { logger, timestampInSeconds } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport type { Hub } from '../hub';\nimport { spanTimeInputToSeconds, spanToJSON } from '../utils/spanUtils';\nimport type { Span } from './span';\nimport { SpanRecorder } from './span';\nimport { Transaction } from './transaction';\n\nexport const TRACING_DEFAULTS = {\n  idleTimeout: 1000,\n  finalTimeout: 30000,\n  heartbeatInterval: 5000,\n};\n\nconst FINISH_REASON_TAG = 'finishReason';\n\nconst IDLE_TRANSACTION_FINISH_REASONS = [\n  'heartbeatFailed',\n  'idleTimeout',\n  'documentHidden',\n  'finalTimeout',\n  'externalFinish',\n  'cancelled',\n];\n\n/**\n * @inheritDoc\n */\nexport class IdleTransactionSpanRecorder extends SpanRecorder {\n  public constructor(\n    private readonly _pushActivity: (id: string) => void,\n    private readonly _popActivity: (id: string) => void,\n    public transactionSpanId: string,\n    maxlen?: number,\n  ) {\n    super(maxlen);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public add(span: Span): void {\n    // We should make sure we do not push and pop activities for\n    // the transaction that this span recorder belongs to.\n    if (span.spanContext().spanId !== this.transactionSpanId) {\n      // We patch span.end() to pop an activity after setting an endTimestamp.\n      // eslint-disable-next-line @typescript-eslint/unbound-method\n      const originalEnd = span.end;\n      span.end = (...rest: unknown[]) => {\n        this._popActivity(span.spanContext().spanId);\n        return originalEnd.apply(span, rest);\n      };\n\n      // We should only push new activities if the span does not have an end timestamp.\n      if (spanToJSON(span).timestamp === undefined) {\n        this._pushActivity(span.spanContext().spanId);\n      }\n    }\n\n    super.add(span);\n  }\n}\n\nexport type BeforeFinishCallback = (transactionSpan: IdleTransaction, endTimestamp: number) => void;\n\n/**\n * An IdleTransaction is a transaction that automatically finishes. It does this by tracking child spans as activities.\n * You can have multiple IdleTransactions active, but if the `onScope` option is specified, the idle transaction will\n * put itself on the scope on creation.\n */\nexport class IdleTransaction extends Transaction {\n  // Activities store a list of active spans\n  public activities: Record<string, boolean>;\n  // Track state of activities in previous heartbeat\n  private _prevHeartbeatString: string | undefined;\n\n  // Amount of times heartbeat has counted. Will cause transaction to finish after 3 beats.\n  private _heartbeatCounter: number;\n\n  // We should not use heartbeat if we finished a transaction\n  private _finished: boolean;\n\n  // Idle timeout was canceled and we should finish the transaction with the last span end.\n  private _idleTimeoutCanceledPermanently: boolean;\n\n  private readonly _beforeFinishCallbacks: BeforeFinishCallback[];\n\n  /**\n   * Timer that tracks Transaction idleTimeout\n   */\n  private _idleTimeoutID: ReturnType<typeof setTimeout> | undefined;\n\n  private _finishReason: (typeof IDLE_TRANSACTION_FINISH_REASONS)[number];\n\n  private _autoFinishAllowed: boolean;\n\n  /**\n   * @deprecated Transactions will be removed in v8. Use spans instead.\n   */\n  public constructor(\n    transactionContext: TransactionContext,\n    // eslint-disable-next-line deprecation/deprecation\n    private readonly _idleHub: Hub,\n    /**\n     * The time to wait in ms until the idle transaction will be finished. This timer is started each time\n     * there are no active spans on this transaction.\n     */\n    private readonly _idleTimeout: number = TRACING_DEFAULTS.idleTimeout,\n    /**\n     * The final value in ms that a transaction cannot exceed\n     */\n    private readonly _finalTimeout: number = TRACING_DEFAULTS.finalTimeout,\n    private readonly _heartbeatInterval: number = TRACING_DEFAULTS.heartbeatInterval,\n    // Whether or not the transaction should put itself on the scope when it starts and pop itself off when it ends\n    private readonly _onScope: boolean = false,\n    /**\n     * When set to `true`, will disable the idle timeout (`_idleTimeout` option) and heartbeat mechanisms (`_heartbeatInterval`\n     * option) until the `sendAutoFinishSignal()` method is called. The final timeout mechanism (`_finalTimeout` option)\n     * will not be affected by this option, meaning the transaction will definitely be finished when the final timeout is\n     * reached, no matter what this option is configured to.\n     *\n     * Defaults to `false`.\n     */\n    delayAutoFinishUntilSignal: boolean = false,\n  ) {\n    super(transactionContext, _idleHub);\n\n    this.activities = {};\n    this._heartbeatCounter = 0;\n    this._finished = false;\n    this._idleTimeoutCanceledPermanently = false;\n    this._beforeFinishCallbacks = [];\n    this._finishReason = IDLE_TRANSACTION_FINISH_REASONS[4];\n    this._autoFinishAllowed = !delayAutoFinishUntilSignal;\n\n    if (_onScope) {\n      // We set the transaction here on the scope so error events pick up the trace\n      // context and attach it to the error.\n      DEBUG_BUILD && logger.log(`Setting idle transaction on scope. Span ID: ${this.spanContext().spanId}`);\n      // eslint-disable-next-line deprecation/deprecation\n      _idleHub.getScope().setSpan(this);\n    }\n\n    if (!delayAutoFinishUntilSignal) {\n      this._restartIdleTimeout();\n    }\n\n    setTimeout(() => {\n      if (!this._finished) {\n        this.setStatus('deadline_exceeded');\n        this._finishReason = IDLE_TRANSACTION_FINISH_REASONS[3];\n        this.end();\n      }\n    }, this._finalTimeout);\n  }\n\n  /** {@inheritDoc} */\n  public end(endTimestamp?: SpanTimeInput): string | undefined {\n    const endTimestampInS = spanTimeInputToSeconds(endTimestamp);\n\n    this._finished = true;\n    this.activities = {};\n\n    // eslint-disable-next-line deprecation/deprecation\n    if (this.op === 'ui.action.click') {\n      this.setAttribute(FINISH_REASON_TAG, this._finishReason);\n    }\n\n    // eslint-disable-next-line deprecation/deprecation\n    if (this.spanRecorder) {\n      DEBUG_BUILD &&\n        // eslint-disable-next-line deprecation/deprecation\n        logger.log('[Tracing] finishing IdleTransaction', new Date(endTimestampInS * 1000).toISOString(), this.op);\n\n      for (const callback of this._beforeFinishCallbacks) {\n        callback(this, endTimestampInS);\n      }\n\n      // eslint-disable-next-line deprecation/deprecation\n      this.spanRecorder.spans = this.spanRecorder.spans.filter((span: Span) => {\n        // If we are dealing with the transaction itself, we just return it\n        if (span.spanContext().spanId === this.spanContext().spanId) {\n          return true;\n        }\n\n        // We cancel all pending spans with status \"cancelled\" to indicate the idle transaction was finished early\n        if (!spanToJSON(span).timestamp) {\n          span.setStatus('cancelled');\n          span.end(endTimestampInS);\n          DEBUG_BUILD &&\n            logger.log('[Tracing] cancelling span since transaction ended early', JSON.stringify(span, undefined, 2));\n        }\n\n        const { start_timestamp: startTime, timestamp: endTime } = spanToJSON(span);\n        const spanStartedBeforeTransactionFinish = startTime && startTime < endTimestampInS;\n\n        // Add a delta with idle timeout so that we prevent false positives\n        const timeoutWithMarginOfError = (this._finalTimeout + this._idleTimeout) / 1000;\n        const spanEndedBeforeFinalTimeout = endTime && startTime && endTime - startTime < timeoutWithMarginOfError;\n\n        if (DEBUG_BUILD) {\n          const stringifiedSpan = JSON.stringify(span, undefined, 2);\n          if (!spanStartedBeforeTransactionFinish) {\n            logger.log('[Tracing] discarding Span since it happened after Transaction was finished', stringifiedSpan);\n          } else if (!spanEndedBeforeFinalTimeout) {\n            logger.log('[Tracing] discarding Span since it finished after Transaction final timeout', stringifiedSpan);\n          }\n        }\n\n        return spanStartedBeforeTransactionFinish && spanEndedBeforeFinalTimeout;\n      });\n\n      DEBUG_BUILD && logger.log('[Tracing] flushing IdleTransaction');\n    } else {\n      DEBUG_BUILD && logger.log('[Tracing] No active IdleTransaction');\n    }\n\n    // if `this._onScope` is `true`, the transaction put itself on the scope when it started\n    if (this._onScope) {\n      // eslint-disable-next-line deprecation/deprecation\n      const scope = this._idleHub.getScope();\n      // eslint-disable-next-line deprecation/deprecation\n      if (scope.getTransaction() === this) {\n        // eslint-disable-next-line deprecation/deprecation\n        scope.setSpan(undefined);\n      }\n    }\n\n    return super.end(endTimestamp);\n  }\n\n  /**\n   * Register a callback function that gets executed before the transaction finishes.\n   * Useful for cleanup or if you want to add any additional spans based on current context.\n   *\n   * This is exposed because users have no other way of running something before an idle transaction\n   * finishes.\n   */\n  public registerBeforeFinishCallback(callback: BeforeFinishCallback): void {\n    this._beforeFinishCallbacks.push(callback);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public initSpanRecorder(maxlen?: number): void {\n    // eslint-disable-next-line deprecation/deprecation\n    if (!this.spanRecorder) {\n      const pushActivity = (id: string): void => {\n        if (this._finished) {\n          return;\n        }\n        this._pushActivity(id);\n      };\n      const popActivity = (id: string): void => {\n        if (this._finished) {\n          return;\n        }\n        this._popActivity(id);\n      };\n\n      // eslint-disable-next-line deprecation/deprecation\n      this.spanRecorder = new IdleTransactionSpanRecorder(pushActivity, popActivity, this.spanContext().spanId, maxlen);\n\n      // Start heartbeat so that transactions do not run forever.\n      DEBUG_BUILD && logger.log('Starting heartbeat');\n      this._pingHeartbeat();\n    }\n    // eslint-disable-next-line deprecation/deprecation\n    this.spanRecorder.add(this);\n  }\n\n  /**\n   * Cancels the existing idle timeout, if there is one.\n   * @param restartOnChildSpanChange Default is `true`.\n   *                                 If set to false the transaction will end\n   *                                 with the last child span.\n   */\n  public cancelIdleTimeout(\n    endTimestamp?: Parameters<IdleTransaction['end']>[0],\n    {\n      restartOnChildSpanChange,\n    }: {\n      restartOnChildSpanChange?: boolean;\n    } = {\n      restartOnChildSpanChange: true,\n    },\n  ): void {\n    this._idleTimeoutCanceledPermanently = restartOnChildSpanChange === false;\n    if (this._idleTimeoutID) {\n      clearTimeout(this._idleTimeoutID);\n      this._idleTimeoutID = undefined;\n\n      if (Object.keys(this.activities).length === 0 && this._idleTimeoutCanceledPermanently) {\n        this._finishReason = IDLE_TRANSACTION_FINISH_REASONS[5];\n        this.end(endTimestamp);\n      }\n    }\n  }\n\n  /**\n   * Temporary method used to externally set the transaction's `finishReason`\n   *\n   * ** WARNING**\n   * This is for the purpose of experimentation only and will be removed in the near future, do not use!\n   *\n   * @internal\n   *\n   */\n  public setFinishReason(reason: string): void {\n    this._finishReason = reason;\n  }\n\n  /**\n   * Permits the IdleTransaction to automatically end itself via the idle timeout and heartbeat mechanisms when the `delayAutoFinishUntilSignal` option was set to `true`.\n   */\n  public sendAutoFinishSignal(): void {\n    if (!this._autoFinishAllowed) {\n      DEBUG_BUILD && logger.log('[Tracing] Received finish signal for idle transaction.');\n      this._restartIdleTimeout();\n      this._autoFinishAllowed = true;\n    }\n  }\n\n  /**\n   * Restarts idle timeout, if there is no running idle timeout it will start one.\n   */\n  private _restartIdleTimeout(endTimestamp?: Parameters<IdleTransaction['end']>[0]): void {\n    this.cancelIdleTimeout();\n    this._idleTimeoutID = setTimeout(() => {\n      if (!this._finished && Object.keys(this.activities).length === 0) {\n        this._finishReason = IDLE_TRANSACTION_FINISH_REASONS[1];\n        this.end(endTimestamp);\n      }\n    }, this._idleTimeout);\n  }\n\n  /**\n   * Start tracking a specific activity.\n   * @param spanId The span id that represents the activity\n   */\n  private _pushActivity(spanId: string): void {\n    this.cancelIdleTimeout(undefined, { restartOnChildSpanChange: !this._idleTimeoutCanceledPermanently });\n    DEBUG_BUILD && logger.log(`[Tracing] pushActivity: ${spanId}`);\n    this.activities[spanId] = true;\n    DEBUG_BUILD && logger.log('[Tracing] new activities count', Object.keys(this.activities).length);\n  }\n\n  /**\n   * Remove an activity from usage\n   * @param spanId The span id that represents the activity\n   */\n  private _popActivity(spanId: string): void {\n    if (this.activities[spanId]) {\n      DEBUG_BUILD && logger.log(`[Tracing] popActivity ${spanId}`);\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete\n      delete this.activities[spanId];\n      DEBUG_BUILD && logger.log('[Tracing] new activities count', Object.keys(this.activities).length);\n    }\n\n    if (Object.keys(this.activities).length === 0) {\n      const endTimestamp = timestampInSeconds();\n      if (this._idleTimeoutCanceledPermanently) {\n        if (this._autoFinishAllowed) {\n          this._finishReason = IDLE_TRANSACTION_FINISH_REASONS[5];\n          this.end(endTimestamp);\n        }\n      } else {\n        // We need to add the timeout here to have the real endtimestamp of the transaction\n        // Remember timestampInSeconds is in seconds, timeout is in ms\n        this._restartIdleTimeout(endTimestamp + this._idleTimeout / 1000);\n      }\n    }\n  }\n\n  /**\n   * Checks when entries of this.activities are not changing for 3 beats.\n   * If this occurs we finish the transaction.\n   */\n  private _beat(): void {\n    // We should not be running heartbeat if the idle transaction is finished.\n    if (this._finished) {\n      return;\n    }\n\n    const heartbeatString = Object.keys(this.activities).join('');\n\n    if (heartbeatString === this._prevHeartbeatString) {\n      this._heartbeatCounter++;\n    } else {\n      this._heartbeatCounter = 1;\n    }\n\n    this._prevHeartbeatString = heartbeatString;\n\n    if (this._heartbeatCounter >= 3) {\n      if (this._autoFinishAllowed) {\n        DEBUG_BUILD && logger.log('[Tracing] Transaction finished because of no change for 3 heart beats');\n        this.setStatus('deadline_exceeded');\n        this._finishReason = IDLE_TRANSACTION_FINISH_REASONS[0];\n        this.end();\n      }\n    } else {\n      this._pingHeartbeat();\n    }\n  }\n\n  /**\n   * Pings the heartbeat\n   */\n  private _pingHeartbeat(): void {\n    DEBUG_BUILD && logger.log(`pinging Heartbeat -> current counter: ${this._heartbeatCounter}`);\n    setTimeout(() => {\n      this._beat();\n    }, this._heartbeatInterval);\n  }\n}\n","/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/ban-types */\nimport type { HandlerDataFetch } from '@sentry/types';\n\nimport { fill } from '../object';\nimport { supportsNativeFetch } from '../supports';\nimport { GLOBAL_OBJ } from '../worldwide';\nimport { addHandler, maybeInstrument, triggerHandlers } from './_handlers';\n\ntype FetchResource = string | { toString(): string } | { url: string };\n\n/**\n * Add an instrumentation handler for when a fetch request happens.\n * The handler function is called once when the request starts and once when it ends,\n * which can be identified by checking if it has an `endTimestamp`.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nexport function addFetchInstrumentationHandler(handler: (data: HandlerDataFetch) => void): void {\n  const type = 'fetch';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentFetch);\n}\n\nfunction instrumentFetch(): void {\n  if (!supportsNativeFetch()) {\n    return;\n  }\n\n  fill(GLOBAL_OBJ, 'fetch', function (originalFetch: () => void): () => void {\n    return function (...args: any[]): void {\n      const { method, url } = parseFetchArgs(args);\n\n      const handlerData: HandlerDataFetch = {\n        args,\n        fetchData: {\n          method,\n          url,\n        },\n        startTimestamp: Date.now(),\n      };\n\n      triggerHandlers('fetch', {\n        ...handlerData,\n      });\n\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access\n      return originalFetch.apply(GLOBAL_OBJ, args).then(\n        (response: Response) => {\n          const finishedHandlerData: HandlerDataFetch = {\n            ...handlerData,\n            endTimestamp: Date.now(),\n            response,\n          };\n\n          triggerHandlers('fetch', finishedHandlerData);\n          return response;\n        },\n        (error: Error) => {\n          const erroredHandlerData: HandlerDataFetch = {\n            ...handlerData,\n            endTimestamp: Date.now(),\n            error,\n          };\n\n          triggerHandlers('fetch', erroredHandlerData);\n          // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n          //       it means the sentry.javascript SDK caught an error invoking your application code.\n          //       This is expected behavior and NOT indicative of a bug with sentry.javascript.\n          throw error;\n        },\n      );\n    };\n  });\n}\n\nfunction hasProp<T extends string>(obj: unknown, prop: T): obj is Record<string, string> {\n  return !!obj && typeof obj === 'object' && !!(obj as Record<string, string>)[prop];\n}\n\nfunction getUrlFromResource(resource: FetchResource): string {\n  if (typeof resource === 'string') {\n    return resource;\n  }\n\n  if (!resource) {\n    return '';\n  }\n\n  if (hasProp(resource, 'url')) {\n    return resource.url;\n  }\n\n  if (resource.toString) {\n    return resource.toString();\n  }\n\n  return '';\n}\n\n/**\n * Parses the fetch arguments to find the used Http method and the url of the request.\n * Exported for tests only.\n */\nexport function parseFetchArgs(fetchArgs: unknown[]): { method: string; url: string } {\n  if (fetchArgs.length === 0) {\n    return { method: 'GET', url: '' };\n  }\n\n  if (fetchArgs.length === 2) {\n    const [url, options] = fetchArgs as [FetchResource, object];\n\n    return {\n      url: getUrlFromResource(url),\n      method: hasProp(options, 'method') ? String(options.method).toUpperCase() : 'GET',\n    };\n  }\n\n  const arg = fetchArgs[0];\n  return {\n    url: getUrlFromResource(arg as FetchResource),\n    method: hasProp(arg, 'method') ? String(arg.method).toUpperCase() : 'GET',\n  };\n}\n","import type { ConsoleLevel } from '@sentry/types';\n\nimport { DEBUG_BUILD } from './debug-build';\nimport { GLOBAL_OBJ } from './worldwide';\n\n/** Prefix for logging strings */\nconst PREFIX = 'Sentry Logger ';\n\nexport const CONSOLE_LEVELS: readonly ConsoleLevel[] = [\n  'debug',\n  'info',\n  'warn',\n  'error',\n  'log',\n  'assert',\n  'trace',\n] as const;\n\ntype LoggerMethod = (...args: unknown[]) => void;\ntype LoggerConsoleMethods = Record<ConsoleLevel, LoggerMethod>;\n\n/** This may be mutated by the console instrumentation. */\nexport const originalConsoleMethods: {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  [key in ConsoleLevel]?: (...args: any[]) => void;\n} = {};\n\n/** JSDoc */\ninterface Logger extends LoggerConsoleMethods {\n  disable(): void;\n  enable(): void;\n  isEnabled(): boolean;\n}\n\n/**\n * Temporarily disable sentry console instrumentations.\n *\n * @param callback The function to run against the original `console` messages\n * @returns The results of the callback\n */\nexport function consoleSandbox<T>(callback: () => T): T {\n  if (!('console' in GLOBAL_OBJ)) {\n    return callback();\n  }\n\n  const console = GLOBAL_OBJ.console as Console;\n  const wrappedFuncs: Partial<LoggerConsoleMethods> = {};\n\n  const wrappedLevels = Object.keys(originalConsoleMethods) as ConsoleLevel[];\n\n  // Restore all wrapped console methods\n  wrappedLevels.forEach(level => {\n    const originalConsoleMethod = originalConsoleMethods[level] as LoggerMethod;\n    wrappedFuncs[level] = console[level] as LoggerMethod | undefined;\n    console[level] = originalConsoleMethod;\n  });\n\n  try {\n    return callback();\n  } finally {\n    // Revert restoration to wrapped state\n    wrappedLevels.forEach(level => {\n      console[level] = wrappedFuncs[level] as LoggerMethod;\n    });\n  }\n}\n\nfunction makeLogger(): Logger {\n  let enabled = false;\n  const logger: Partial<Logger> = {\n    enable: () => {\n      enabled = true;\n    },\n    disable: () => {\n      enabled = false;\n    },\n    isEnabled: () => enabled,\n  };\n\n  if (DEBUG_BUILD) {\n    CONSOLE_LEVELS.forEach(name => {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      logger[name] = (...args: any[]) => {\n        if (enabled) {\n          consoleSandbox(() => {\n            GLOBAL_OBJ.console[name](`${PREFIX}[${name}]:`, ...args);\n          });\n        }\n      };\n    });\n  } else {\n    CONSOLE_LEVELS.forEach(name => {\n      logger[name] = () => undefined;\n    });\n  }\n\n  return logger as Logger;\n}\n\nexport const logger = makeLogger();\n","import type { IdleTransaction, SpanStatusType } from '@sentry/core';\nimport { getActiveTransaction, spanToJSON } from '@sentry/core';\nimport { logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../common/debug-build';\nimport { WINDOW } from './types';\n\n/**\n * Add a listener that cancels and finishes a transaction when the global\n * document is hidden.\n */\nexport function registerBackgroundTabDetection(): void {\n  if (WINDOW.document) {\n    WINDOW.document.addEventListener('visibilitychange', () => {\n      // eslint-disable-next-line deprecation/deprecation\n      const activeTransaction = getActiveTransaction() as IdleTransaction;\n      if (WINDOW.document!.hidden && activeTransaction) {\n        const statusType: SpanStatusType = 'cancelled';\n\n        const { op, status } = spanToJSON(activeTransaction);\n\n        DEBUG_BUILD &&\n          logger.log(`[Tracing] Transaction: ${statusType} -> since tab moved to the background, op: ${op}`);\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          activeTransaction.setStatus(statusType);\n        }\n        // TODO: Can we rewrite this to an attribute?\n        // eslint-disable-next-line deprecation/deprecation\n        activeTransaction.setTag('visibilitychange', 'document.hidden');\n        activeTransaction.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","import type { Options, SamplingContext } from '@sentry/types';\nimport { isNaN, logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from '../debug-build';\nimport { SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE } from '../semanticAttributes';\nimport { hasTracingEnabled } from '../utils/hasTracingEnabled';\nimport { spanToJSON } from '../utils/spanUtils';\nimport type { Transaction } from './transaction';\n\n/**\n * Makes a sampling decision for the given transaction and stores it on the transaction.\n *\n * Called every time a transaction is created. Only transactions which emerge with a `sampled` value of `true` will be\n * sent to Sentry.\n *\n * This method muttes the given `transaction` and will set the `sampled` value on it.\n * It returns the same transaction, for convenience.\n */\nexport function sampleTransaction<T extends Transaction>(\n  transaction: T,\n  options: Pick<Options, 'tracesSampleRate' | 'tracesSampler' | 'enableTracing'>,\n  samplingContext: SamplingContext,\n): T {\n  // nothing to do if tracing is not enabled\n  if (!hasTracingEnabled(options)) {\n    // eslint-disable-next-line deprecation/deprecation\n    transaction.sampled = false;\n    return transaction;\n  }\n\n  // if the user has forced a sampling decision by passing a `sampled` value in their transaction context, go with that\n  // eslint-disable-next-line deprecation/deprecation\n  if (transaction.sampled !== undefined) {\n    // eslint-disable-next-line deprecation/deprecation\n    transaction.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, Number(transaction.sampled));\n    return transaction;\n  }\n\n  // we would have bailed already if neither `tracesSampler` nor `tracesSampleRate` nor `enableTracing` were defined, so one of these should\n  // work; prefer the hook if so\n  let sampleRate;\n  if (typeof options.tracesSampler === 'function') {\n    sampleRate = options.tracesSampler(samplingContext);\n    transaction.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, Number(sampleRate));\n  } else if (samplingContext.parentSampled !== undefined) {\n    sampleRate = samplingContext.parentSampled;\n  } else if (typeof options.tracesSampleRate !== 'undefined') {\n    sampleRate = options.tracesSampleRate;\n    transaction.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, Number(sampleRate));\n  } else {\n    // When `enableTracing === true`, we use a sample rate of 100%\n    sampleRate = 1;\n    transaction.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE, sampleRate);\n  }\n\n  // Since this is coming from the user (or from a function provided by the user), who knows what we might get. (The\n  // only valid values are booleans or numbers between 0 and 1.)\n  if (!isValidSampleRate(sampleRate)) {\n    DEBUG_BUILD && logger.warn('[Tracing] Discarding transaction because of invalid sample rate.');\n    // eslint-disable-next-line deprecation/deprecation\n    transaction.sampled = false;\n    return transaction;\n  }\n\n  // if the function returned 0 (or false), or if `tracesSampleRate` is 0, it's a sign the transaction should be dropped\n  if (!sampleRate) {\n    DEBUG_BUILD &&\n      logger.log(\n        `[Tracing] Discarding transaction because ${\n          typeof options.tracesSampler === 'function'\n            ? 'tracesSampler returned 0 or false'\n            : 'a negative sampling decision was inherited or tracesSampleRate is set to 0'\n        }`,\n      );\n    // eslint-disable-next-line deprecation/deprecation\n    transaction.sampled = false;\n    return transaction;\n  }\n\n  // Now we roll the dice. Math.random is inclusive of 0, but not of 1, so strict < is safe here. In case sampleRate is\n  // a boolean, the < comparison will cause it to be automatically cast to 1 if it's true and 0 if it's false.\n  // eslint-disable-next-line deprecation/deprecation\n  transaction.sampled = Math.random() < (sampleRate as number | boolean);\n\n  // if we're not going to keep it, we're done\n  // eslint-disable-next-line deprecation/deprecation\n  if (!transaction.sampled) {\n    DEBUG_BUILD &&\n      logger.log(\n        `[Tracing] Discarding transaction because it's not included in the random sample (sampling rate = ${Number(\n          sampleRate,\n        )})`,\n      );\n    return transaction;\n  }\n\n  DEBUG_BUILD &&\n    // eslint-disable-next-line deprecation/deprecation\n    logger.log(`[Tracing] starting ${transaction.op} transaction - ${spanToJSON(transaction).description}`);\n  return transaction;\n}\n\n/**\n * Checks the given sample rate to make sure it is valid type and value (a boolean, or a number between 0 and 1).\n */\nexport function isValidSampleRate(rate: unknown): boolean {\n  // we need to check NaN explicitly because it's of type 'number' and therefore wouldn't get caught by this typecheck\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  if (isNaN(rate) || !(typeof rate === 'number' || typeof rate === 'boolean')) {\n    DEBUG_BUILD &&\n      logger.warn(\n        `[Tracing] Given sample rate is invalid. Sample rate must be a boolean or a number between 0 and 1. Got ${JSON.stringify(\n          rate,\n        )} of type ${JSON.stringify(typeof rate)}.`,\n      );\n    return false;\n  }\n\n  // in case sampleRate is a boolean, it will get automatically cast to 1 if it's true and 0 if it's false\n  if (rate < 0 || rate > 1) {\n    DEBUG_BUILD &&\n      logger.warn(`[Tracing] Given sample rate is invalid. Sample rate must be between 0 and 1. Got ${rate}.`);\n    return false;\n  }\n  return true;\n}\n","import type { ClientReport, ClientReportEnvelope, ClientReportItem } from '@sentry/types';\n\nimport { createEnvelope } from './envelope';\nimport { dateTimestampInSeconds } from './time';\n\n/**\n * Creates client report envelope\n * @param discarded_events An array of discard events\n * @param dsn A DSN that can be set on the header. Optional.\n */\nexport function createClientReportEnvelope(\n  discarded_events: ClientReport['discarded_events'],\n  dsn?: string,\n  timestamp?: number,\n): ClientReportEnvelope {\n  const clientReportItem: ClientReportItem = [\n    { type: 'client_report' },\n    {\n      timestamp: timestamp || dateTimestampInSeconds(),\n      discarded_events,\n    },\n  ];\n  return createEnvelope<ClientReportEnvelope>(dsn ? { dsn } : {}, [clientReportItem]);\n}\n","import type { Scope } from '@sentry/core';\nimport { applySdkMetadata } from '@sentry/core';\nimport { BaseClient } from '@sentry/core';\nimport type {\n  BrowserClientProfilingOptions,\n  BrowserClientReplayOptions,\n  ClientOptions,\n  Event,\n  EventHint,\n  Options,\n  ParameterizedString,\n  Severity,\n  SeverityLevel,\n  UserFeedback,\n} from '@sentry/types';\nimport { createClientReportEnvelope, dsnToString, getSDKSource, logger } from '@sentry/utils';\n\nimport { DEBUG_BUILD } from './debug-build';\nimport { eventFromException, eventFromMessage } from './eventbuilder';\nimport { WINDOW } from './helpers';\nimport type { BrowserTransportOptions } from './transports/types';\nimport { createUserFeedbackEnvelope } from './userfeedback';\n\n/**\n * Configuration options for the Sentry Browser SDK.\n * @see @sentry/types Options for more information.\n */\nexport type BrowserOptions = Options<BrowserTransportOptions> &\n  BrowserClientReplayOptions &\n  BrowserClientProfilingOptions;\n\n/**\n * Configuration options for the Sentry Browser SDK Client class\n * @see BrowserClient for more information.\n */\nexport type BrowserClientOptions = ClientOptions<BrowserTransportOptions> &\n  BrowserClientReplayOptions &\n  BrowserClientProfilingOptions;\n\n/**\n * The Sentry Browser SDK Client.\n *\n * @see BrowserOptions for documentation on configuration options.\n * @see SentryClient for usage documentation.\n */\nexport class BrowserClient extends BaseClient<BrowserClientOptions> {\n  /**\n   * Creates a new Browser SDK instance.\n   *\n   * @param options Configuration options for this SDK.\n   */\n  public constructor(options: BrowserClientOptions) {\n    const sdkSource = WINDOW.SENTRY_SDK_SOURCE || getSDKSource();\n    applySdkMetadata(options, 'browser', ['browser'], sdkSource);\n\n    super(options);\n\n    if (options.sendClientReports && WINDOW.document) {\n      WINDOW.document.addEventListener('visibilitychange', () => {\n        if (WINDOW.document.visibilityState === 'hidden') {\n          this._flushOutcomes();\n        }\n      });\n    }\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public eventFromException(exception: unknown, hint?: EventHint): PromiseLike<Event> {\n    return eventFromException(this._options.stackParser, exception, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  public eventFromMessage(\n    message: ParameterizedString,\n    // eslint-disable-next-line deprecation/deprecation\n    level: Severity | SeverityLevel = 'info',\n    hint?: EventHint,\n  ): PromiseLike<Event> {\n    return eventFromMessage(this._options.stackParser, message, level, hint, this._options.attachStacktrace);\n  }\n\n  /**\n   * Sends user feedback to Sentry.\n   */\n  public captureUserFeedback(feedback: UserFeedback): void {\n    if (!this._isEnabled()) {\n      DEBUG_BUILD && logger.warn('SDK not enabled, will not capture user feedback.');\n      return;\n    }\n\n    const envelope = createUserFeedbackEnvelope(feedback, {\n      metadata: this.getSdkMetadata(),\n      dsn: this.getDsn(),\n      tunnel: this.getOptions().tunnel,\n    });\n\n    // _sendEnvelope should not throw\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this._sendEnvelope(envelope);\n  }\n\n  /**\n   * @inheritDoc\n   */\n  protected _prepareEvent(event: Event, hint: EventHint, scope?: Scope): PromiseLike<Event | null> {\n    event.platform = event.platform || 'javascript';\n    return super._prepareEvent(event, hint, scope);\n  }\n\n  /**\n   * Sends client reports as an envelope.\n   */\n  private _flushOutcomes(): void {\n    const outcomes = this._clearOutcomes();\n\n    if (outcomes.length === 0) {\n      DEBUG_BUILD && logger.log('No outcomes to send');\n      return;\n    }\n\n    // This is really the only place where we want to check for a DSN and only send outcomes then\n    if (!this._dsn) {\n      DEBUG_BUILD && logger.log('No dsn provided, will not send outcomes');\n      return;\n    }\n\n    DEBUG_BUILD && logger.log('Sending outcomes:', outcomes);\n\n    const envelope = createClientReportEnvelope(outcomes, this._options.tunnel && dsnToString(this._dsn));\n\n    // _sendEnvelope should not throw\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this._sendEnvelope(envelope);\n  }\n}\n","import type { Options } from '@sentry/types';\nimport { SDK_VERSION } from '../version';\n\n/**\n * A builder for the SDK metadata in the options for the SDK initialization.\n *\n * Note: This function is identical to `buildMetadata` in Remix and NextJS and SvelteKit.\n * We don't extract it for bundle size reasons.\n * @see https://github.com/getsentry/sentry-javascript/pull/7404\n * @see https://github.com/getsentry/sentry-javascript/pull/4196\n *\n * If you make changes to this function consider updating the others as well.\n *\n * @param options SDK options object that gets mutated\n * @param names list of package names\n */\nexport function applySdkMetadata(options: Options, name: string, names = [name], source = 'npm'): void {\n  const metadata = options._metadata || {};\n\n  if (!metadata.sdk) {\n    metadata.sdk = {\n      name: `sentry.javascript.${name}`,\n      packages: names.map(name => ({\n        name: `${source}:@sentry/${name}`,\n        version: SDK_VERSION,\n      })),\n      version: SDK_VERSION,\n    };\n  }\n\n  options._metadata = metadata;\n}\n","// https://github.com/alangpierce/sucrase/tree/265887868966917f3b924ce38dfad01fbab1329f\n//\n// The MIT License (MIT)\n//\n// Copyright (c) 2012-2018 various contributors (see AUTHORS)\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\nimport type { GenericFunction } from './types';\n\n/**\n * Polyfill for the optional chain operator, `?.`, given previous conversion of the expression into an array of values,\n * descriptors, and functions.\n *\n * Adapted from Sucrase (https://github.com/alangpierce/sucrase)\n * See https://github.com/alangpierce/sucrase/blob/265887868966917f3b924ce38dfad01fbab1329f/src/transformers/OptionalChainingNullishTransformer.ts#L15\n *\n * @param ops Array result of expression conversion\n * @returns The value of the expression\n */\nexport function _optionalChain(ops: unknown[]): unknown {\n  let lastAccessLHS: unknown = undefined;\n  let value = ops[0];\n  let i = 1;\n  while (i < ops.length) {\n    const op = ops[i] as string;\n    const fn = ops[i + 1] as (intermediateValue: unknown) => unknown;\n    i += 2;\n    // by checking for loose equality to `null`, we catch both `null` and `undefined`\n    if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {\n      // really we're meaning to return `undefined` as an actual value here, but it saves bytes not to write it\n      return;\n    }\n    if (op === 'access' || op === 'optionalAccess') {\n      lastAccessLHS = value;\n      value = fn(value);\n    } else if (op === 'call' || op === 'optionalCall') {\n      value = fn((...args: unknown[]) => (value as GenericFunction).call(lastAccessLHS, ...args));\n      lastAccessLHS = undefined;\n    }\n  }\n  return value;\n}\n\n// Sucrase version\n// function _optionalChain(ops) {\n//   let lastAccessLHS = undefined;\n//   let value = ops[0];\n//   let i = 1;\n//   while (i < ops.length) {\n//     const op = ops[i];\n//     const fn = ops[i + 1];\n//     i += 2;\n//     if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) {\n//       return undefined;\n//     }\n//     if (op === 'access' || op === 'optionalAccess') {\n//       lastAccessLHS = value;\n//       value = fn(value);\n//     } else if (op === 'call' || op === 'optionalCall') {\n//       value = fn((...args) => value.call(lastAccessLHS, ...args));\n//       lastAccessLHS = undefined;\n//     }\n//   }\n//   return value;\n// }\n"],"names":["createSpanEnvelope","spans","dsn","headers","sent_at","Date","toISOString","dsnToString","items","map","createSpanItem","createEnvelope","span","type","isMeasurementValue","value","isFinite","_startChild","transaction","_ref","startTimestamp","ctx","_objectWithoutProperties","_excluded","startChild","_objectSpread","MAX_INT_AS_BYTES","msToSec","time","getBrowserPerformanceAPI","WINDOW","addEventListener","performance","_lcpEntry","_clsEntry","_performanceCursor","_measurements","startTrackingWebVitals","browserPerformanceTimeOrigin","mark","fidCallback","addFidInstrumentationHandler","_ref5","metric","entry","entries","length","timeOrigin","startTime","DEBUG_BUILD","logger","log","unit","clsCallback","addClsInstrumentationHandler","_ref3","lcpCallback","addLcpInstrumentationHandler","_ref4","ttfbCallback","addTtfbInstrumentationHandler","_ref6","startTrackingLongTasks","addPerformanceInstrumentationHandler","_step","_iterator","_createForOfIteratorHelper","s","n","done","getActiveTransaction","duration","description","op","origin","endTimestamp","err","e","f","startTrackingInteractions","_ref2","_step2","_iterator2","name","htmlTreeAsString","target","concat","componentName","getComponentName","attributes","startTrackingINP","interactionIdtoRouteNameMapping","interactionsSampleRate","inpCallback","interactionIdToRouteNameMapping","addInpInstrumentationHandler","_ref7","undefined","find","INP_ENTRY_MAP","client","getClient","interactionType","options","getOptions","interaction","interactionId","routeName","parentContext","activeTransaction","user","replayId","userDisplay","email","id","ip_address","profileId","getProfileId","Span","release","environment","profile_id","replay_id","exclusiveTime","measurements","inp","sampleRate","transactionContext","hasTracingEnabled","tracesSampler","parentSampled","data","location","sampled","tracesSampleRate","isValidSampleRate","warn","getSampleRate","Math","random","envelope","getDsn","transport","getTransport","send","then","reason","error","_trackINP","click","pointerdown","pointerup","mousedown","mouseup","touchstart","touchend","mouseover","mouseout","mouseenter","mouseleave","pointerover","pointerout","pointerenter","pointerleave","dragstart","dragend","drag","dragenter","dragleave","dragover","drop","keydown","keyup","keypress","input","addPerformanceEntries","getEntries","performanceEntries","_spanToJSON","spanToJSON","transactionStartTime","start_timestamp","slice","forEach","entryType","event","_addPerformanceNavigationTiming","responseEnd","requestStart","responseStart","_addRequest","_addNavigationSpans","measureStartTimestamp","measureEndTimestamp","_addMeasureSpans","firstHidden","getVisibilityWatcher","shouldRecord","firstHiddenTime","resourceUrl","initiatorType","parsedUrl","parseUrl","setResourceEntrySizeData","renderBlockingStatus","protocol","split","pop","host","includes","replace","_addResourceSpans","max","navigator","connection","effectiveType","setTag","rtt","deviceMemory","hardwareConcurrency","String","_trackNavigator","navEntry","getNavigationEntry","_addTtfbRequestTimeToMeasurements","oldValue","measurementTimestamp","normalizedValue","abs","delta","fidMark","cls","Object","keys","measurementName","setMeasurement","element","url","trim","size","sources","source","index","node","_tagMetricInfo","eventEnd","end","start","key","dataKey","entryVal","SpanStatus","getSpanStatusFromHttpCode","httpStatus","spanStatusfromHttpCode","setHttpStatus","setData","spanStatus","setStatus","validSeverityLevels","severityLevelFromString","level","exceptionFromError","stackParser","ex","frames","parseStackFrames","exception","extractMessage","stacktrace","eventFromError","values","stack","popSize","framesToPop","reactMinifiedRegexp","test","message","getPopSize","eventFromException","hint","attachStacktrace","eventFromUnknownInput","syntheticException","addExceptionMechanism","event_id","resolvedSyncPromise","eventFromMessage","arguments","eventFromString","isUnhandledRejection","isErrorEvent","isDOMError","isDOMException","domException","addExceptionTypeValue","tags","code","isError","isPlainObject","isEvent","normalizeDepth","constructor","getNonErrorObjectExceptionValue","extra","__serialized__","normalizeToSize","eventFromPlainObject","synthetic","isParameterizedString","__sentry_template_string__","__sentry_template_values__","logentry","params","extractExceptionKeysForMessage","captureType","className","obj","prototype","getPrototypeOf","getObjectClassName","SPAN_METRIC_SUMMARY","getMetricStorageForSpan","get","getMetricSummaryJsonForSpan","storage","output","_slicedToArray","_ref2$","exportKey","summary","push","dropUndefinedKeys","updateMetricSummaryOnActiveSpan","metricType","sanitizedName","bucketKey","getActiveSpan","Map","bucketItem","set","min","count","sum","WeakMap","SENTRY_API_VERSION","getBaseApiEndpoint","port","path","_encodedAuth","sdkInfo","urlEncode","sentry_key","publicKey","sentry_version","sentry_client","version","getEnvelopeEndpointWithUrlEncodedAuth","tunnelOrOptions","tunnel","_metadata","sdk","projectId","_getIngestEndpoint","getReportDialogEndpoint","dsnLike","dialogOptions","makeDsn","endpoint","encodedOptions","encodeURIComponent","addConsoleInstrumentationHandler","handler","addHandler","maybeInstrument","instrumentConsole","CONSOLE_LEVELS","GLOBAL_OBJ","console","fill","originalConsoleMethod","originalConsoleMethods","_len","args","Array","_key","handlerData","triggerHandlers","apply","API_VERSION","parseFloat","SDK_VERSION","Hub","scope","isolationScope","assignedScope","assignedIsolationScope","_version","_classCallCheck","Scope","setClient","this","_stack","bindClient","_isolationScope","top","getStackTop","setupIntegrations","getScope","clone","getStack","callback","maybePromiseResult","_this","pushScope","popScope","isThenable","res","eventId","_lastEventId","uuid4","Error","captureException","originalException","captureMessage","captureEvent","breadcrumb","_this$getStackTop","_ref$beforeBreadcrumb","beforeBreadcrumb","_ref$maxBreadcrumbs","maxBreadcrumbs","mergedBreadcrumb","timestamp","dateTimestampInSeconds","finalBreadcrumb","consoleSandbox","emit","addBreadcrumb","setUser","getIsolationScope","setTags","extras","setExtras","setExtra","context","setContext","_this$getStackTop2","oldHub","makeMain","integration","getIntegration","_oO","customSamplingContext","result","_callExtensionMethod","endSession","_sendSessionUpdate","session","getSession","closeSession","setSession","_this$getStackTop3","_ref2$environment","DEFAULT_ENVIRONMENT","userAgent","makeSession","getUser","currentSession","status","updateSession","Boolean","sendDefaultPii","_this$getStackTop4","captureSession","method","sentry","getMainCarrier","__SENTRY__","extensions","hub","registry","getHubFromCarrier","setHubOnCarrier","getCurrentHub","acs","getGlobalHub","hasHubOnCarrier","isOlderThan","runWithAsyncContext","carrier","getGlobalSingleton","po","bindReporter","reportAllChanges","prevValue","forceReport","getActivationStart","activationStart","initMetric","navigationType","document","prerendering","rating","now","floor","observe","opts","PerformanceObserver","supportedEntryTypes","list","assign","buffered","onCLS","onReport","report","sessionValue","sessionEntries","handleEntries","hadRecentInput","firstSessionEntry","lastSessionEntry","stopListening","takeRecords","onHidden","onFID","visibilityWatcher","handleEntry","processingStart","disconnect","interactionCountEstimate","minKnownInteractionId","Infinity","maxKnownInteractionId","updateEstimate","initInteractionCountPolyfill","durationThreshold","getInteractionCountForNavigation","interactionCount","longestInteractionList","longestInteractionMap","processEntry","minLongestInteraction","existingInteraction","latency","sort","a","b","splice","i","onINP","some","prevEntry","candidateInteractionIndex","reportedMetricIDs","onLCP","lastEntry","once","capture","whenReady","readyState","setTimeout","onTTFB","_previousCls","_previousFid","_previousLcp","_previousTtfb","_previousInp","handlers","instrumented","addMetricObserver","instrumentCls","instrumentLcp","instrumentTtfb","instrumentFid","instrumentInp","instrumentPerformanceObserver","getCleanupCallback","typeHandlers","getFunctionName","instrumentFn","previousValue","stopOnCallback","indexOf","maybeOptions","__SENTRY_TRACING__","enableTracing","__SENTRY_DEBUG__","makePromiseBuffer","limit","buffer","remove","task","$","add","taskProducer","rejectedSyncPromise","SentryError","drain","timeout","SyncPromise","resolve","reject","counter","capturedSetTimeout","item","clearTimeout","DEFAULT_TRANSPORT_BUFFER_SIZE","createTransport","makeRequest","bufferSize","rateLimits","filteredEnvelopeItems","forEachEnvelopeItem","dataCategory","envelopeItemTypeToDataCategory","isRateLimited","getEventForEnvelopeItem","recordDroppedEvent","filteredEnvelope","recordEnvelopeLoss","body","serializeEnvelope","textEncoder","response","statusCode","updateRateLimits","__sentry__baseTransport__","flush","isArray","_Error","logLevel","_callSuper","setPrototypeOf","_inherits","_wrapNativeSuper","getGlobalEventProcessors","addGlobalEventProcessor","notifyEventProcessors","processors","processor","final","globalScope","_notifyingListeners","_scopeListeners","_eventProcessors","_breadcrumbs","_attachments","_user","_tags","_extra","_contexts","_sdkProcessingMetadata","_propagationContext","generatePropagationContext","newScope","_toConsumableArray","_level","_span","_session","_transactionName","_fingerprint","_requestSession","_client","segment","username","_notifyScopeListeners","requestSession","_defineProperty","fingerprint","captureContext","scopeToMerge","scopeData","getScopeData","contexts","getRequestSession","propagationContext","scopeContext","maxCrumbs","breadcrumbs","attachment","attachments","eventProcessors","sdkProcessingMetadata","transactionName","additionalEventProcessors","applyScopeDataToEvent","newData","getGlobalScope","traceId","spanId","substring","ONE_SECOND_IN_MS","timestampInSeconds","approxStartingTimeOrigin","createUnixTimestampInSecondsFunc","threshold","performanceNow","dateNow","timeOriginDelta","timeOriginIsReliable","navigationStart","timing","navigationStartDelta","_browserPerformanceTimeOriginMode","parseEventHintOrCaptureContext","configureScope","withScope","rest","withIsolationScope","withActiveSpan","setSpan","startTransaction","_x","_flush","_asyncToGenerator","_regeneratorRuntime","_callee","wrap","_context","prev","next","abrupt","Promise","stop","close","_x2","_close","_callee2","_context2","lastEventId","isInitialized","getCurrentScope","startSession","currentScope","_ref$environment","MAX_ALLOWED_STRING_LENGTH","INTEGRATION_NAME","breadcrumbsIntegration","defineIntegration","_options","dom","fetch","history","xhr","setupOnce","setup","category","safeJoin","_getConsoleBreadcrumbHandler","addClickKeypressInstrumentationHandler","keyAttrs","serializeAttribute","maxStringLength","_isEvent","global","_getDomBreadcrumbHandler","addXhrInstrumentationHandler","sentryXhrData","SENTRY_XHR_DATA_KEY","status_code","_getXhrBreadcrumbHandler","addFetchInstrumentationHandler","fetchData","match","_getFetchBreadcrumbHandler","addHistoryInstrumentationHandler","from","to","parsedLoc","href","parsedFrom","parsedTo","relative","_getHistoryBreadcrumbHandler","on","getEventDescription","_getSentryBreadcrumbHandler","Breadcrumbs","convertIntegrationFnToClass","NodeType$1","REPLAY_SESSION_KEY","UNABLE_TO_SEND_REPLAY","NETWORK_BODY_MAX_SIZE","CONSOLE_ARG_MAX_SIZE","REPLAY_MAX_EVENT_BUFFER_SIZE","MAX_REPLAY_DURATION","_optionalChain$5","ops","lastAccessLHS","fn","_value2","call","isShadowRoot","_","_2","shadowRoot","isNativeShadowDom","toString","stringifyStylesheet","rules","cssRules","cssText","stringifyRule","join","rule","importStringified","cssStringified","regex","isCSSImportRule","styleSheet","statement","JSON","stringify","layerName","supportsText","media","mediaText","escapeImportStatement","isCSSStyleRule","selectorText","NodeType","Mirror","_createClass","idNodeMap","nodeMetaMap","lhs","rhsFn","_3","getMeta","_4","_5","getId","childNodes","childNode","removeNodeFromMap","has","meta","oldNode","getNode","shouldMaskInput","maskInputOptions","tagName","toLowerCase","maskInputValue","isMasked","maskInputFn","text","repeat","str","toUpperCase","ORIGINAL_ATTRIBUTE_NAME","getInputType","hasAttribute","getInputValue","el","getAttribute","canvasService","canvasCtx","_id","tagNameRegex","RegExp","genId","URL_IN_CSS_REF","URL_PROTOCOL_MATCH","URL_WWW_MATCH","DATA_URI","absoluteToStylesheet","quote1","path1","quote2","path2","path3","filePath","maybeQuote","parts","part","SRCSET_NOT_SPACES","SRCSET_COMMAS_OR_SPACES","absoluteToDoc","doc","attributeValue","createElement","isSVGElement","ownerSVGElement","getHref","transformAttribute","maskAttributeFn","pos","collectCharacters","regEx","chars","exec","descriptorsStr","inParens","c","charAt","getAbsoluteSrcsetString","ignoreAttribute","_value","distanceToMatch","matchPredicate","distance","nodeType","ELEMENT_NODE","parentNode","createMatchPredicate","selector","matches","eIndex","classList","elementClassMatchesRegex","e2","needMaskingText","maskTextClass","maskTextSelector","unmaskTextClass","unmaskTextSelector","maskAllText","parentElement","autocomplete","maskDistance","unmaskDistance","serializeNode","mirror","blockClass","blockSelector","unblockSelector","inlineStylesheet","_options$maskInputOpt","maskTextFn","_options$dataURLOptio","dataURLOptions","inlineImages","recordCanvas","keepIframeSrcFn","_options$newlyAddedEl","newlyAddedElement","rootId","hasNode","docId","getRootId","DOCUMENT_NODE","compatMode","Document","DOCUMENT_TYPE_NODE","DocumentType","publicId","systemId","isCustomElement","_options$maskInputOpt2","_options$dataURLOptio2","_options$newlyAddedEl2","needBlock","contains","_isBlockedElement","HTMLFormElement","processedTagName","getValidTagName","len","attr","stylesheet","styleSheets","rel","_cssText","sheet","innerText","textContent","checked","forceMask","selected","__context","canvas","getContext","x","width","y","height","getImageData","originalGetImageData","Uint32Array","pixel","is2DCanvasBlank","rr_dataURL","toDataURL","quality","canvasDataURL","blankCanvas","image","crossOrigin","recordInlineImage","removeEventListener","naturalWidth","naturalHeight","drawImage","currentSrc","removeAttribute","complete","rr_mediaState","paused","rr_mediaCurrentTime","currentTime","scrollLeft","rr_scrollLeft","scrollTop","rr_scrollTop","_n$getBoundingClientR","getBoundingClientRect","rr_width","rr_height","src","contentDocument","rr_src","customElements","Element","isSVG","isCustom","serializeElementNode","TEXT_NODE","parentTagName","isStyle","isScript","isTextarea","nextSibling","previousSibling","_6","_7","_8","textarea","Text","serializeTextNode","CDATA_SECTION_NODE","CDATA","COMMENT_NODE","Comment","lowerIfExists","maybeAttr","serializeNodeWithId","_options$skipChild","skipChild","_options$inlineStyles","_options$maskInputOpt3","slimDOMOptions","_options$dataURLOptio3","_options$inlineImages","_options$recordCanvas","onSerialize","onIframeLoad","_options$iframeLoadTi","iframeLoadTimeout","onStylesheetLoad","_options$stylesheetLo","stylesheetLoadTimeout","_options$keepIframeSr","_options$newlyAddedEl3","_options$preserveWhit","preserveWhiteSpace","_serializedNode","sn","comment","script","as","endsWith","headFavicon","headMetaDescKeywords","headMetaSocial","property","headMetaRobots","headMetaHttpEquiv","headMetaAuthorship","headMetaVerification","slimDOMExcluded","serializedNode","recordChild","isShadowHost","headWhitespace","bypassOptions","_i","_Array$from","serializedChildNode","isElement$1","_i2","_Array$from2","isShadow","iframeEl","listener","win","contentWindow","fired","blankUrl","timer","onceIframeLoaded","iframeDoc","serializedIframeNode","link","styleSheetLoadTimeout","styleSheetLoaded","onceStylesheetLoaded","serializedLinkNode","_optionalChain$4","_value3","_len2","_key2","passive","DEPARTED_MIRROR_ACCESS_WARNING","_mirror","reset","throttle$1","func","wait","previous","_len3","_key3","leading","remaining","getImplementation","clearTimeout$1","trailing","setTimeout$1","hookSetter","d","isRevoked","window","original","getOwnPropertyDescriptor","defineProperty","_this2","patch","replacement","wrapped","defineProperties","__rrweb_original__","enumerable","Proxy","Reflect","prop","receiver","nowTimestamp","getWindowScroll","left","scrollingElement","pageXOffset","documentElement","pageYOffset","_9","_10","_11","_12","_13","_14","getWindowHeight","innerHeight","clientHeight","getWindowWidth","innerWidth","clientWidth","closestElementOfNode","isBlocked","checkAncestors","blockedPredicate","isUnblocked","blockDistance","unblockDistance","isIgnored","isAncestorRemoved","legacy_isTouchEvent","changedTouches","isSerializedIframe","nodeName","isSerializedStylesheet","hasShadowRoot","_18","getTime","StyleSheetMirror","styleIDMap","idStyleMap","newId","getShadowHost","shadowHost","_19","getRootNode","_20","_21","Node","DOCUMENT_FRAGMENT_NODE","shadowHostInDom","ownerDocument","rootShadowHost","getRootShadowHost","inDom","cachedImplementations","cached","impl","sandbox","hidden","head","appendChild","removeChild","bind","EventType","EventType2","IncrementalSource","IncrementalSource2","MouseInteractions","MouseInteractions2","PointerTypes","PointerTypes2","_optionalChain$3","_value4","_len5","_key5","isNodeInLinkedList","errorHandler","DoubleLinkedList","tail","position","current","__ln","moveKey","parentId","MutationBuffer","_this4","frozen","locked","texts","attributeMap","removes","mapRemoves","movedMap","addedSet","Set","movedSet","droppedSet","processMutations","mutations","processMutation","adds","addedIds","addList","getNextId","ns","nextId","pushAdd","addNode","currentN","iframeManager","addIframe","stylesheetManager","trackLinkElement","shadowDomManager","addShadowRoot","iframe","childSn","attachIframe","observeAttachShadow","attachLinkElement","shift","isParentRemoved","_step3","_iterator3","isAncestorInSet","candidate","tailNode","_node","unhandledNode","removeNode","payload","filter","attribute","style","diffAsStr","styleDiff","unchangedAsStr","_unchangedStyles","mutationCb","m","attributeName","isInputMasked","setAttribute","unattachedDoc","implementation","createHTMLDocument","old","_i3","_Array$from3","pname","newValue","getPropertyValue","newPriority","getPropertyPriority","_i4","_Array$from4","addedNodes","genAdds","removedNodes","nodeId","isSerialized","deepDelete","processedNodeManager","inOtherBuffer","targetId","childN","_this5","canvasManager","freeze","unfreeze","lock","unlock","addsSet","_isParentRemoved","r","_isAncestorInSet","registerErrorHandler","unregisterErrorHandler","callbackWrapper","cb","_optionalChain$2","_value6","_len6","_key6","mutationBuffers","getEventTarget","composedPath","initMutationObserver","rootEl","mutationBuffer","init","mutationObserverCtor","MutationObserver","__rrMutationObserver","angularZoneSymbol","Zone","__symbol__","observer","onMutation","attributeOldValue","characterData","characterDataOldValue","childList","subtree","initMouseInteractionObserver","mouseInteractionCb","sampling","mouseInteraction","disableMap","currentPointerType","Number","isNaN","eventKey","eventName","pointerType","thisEventKey","Mouse","Touch","Pen","MouseDown","MouseUp","startsWith","Click","clientX","clientY","getHandler","PointerEvent","TouchStart","TouchEnd","h","initScrollObserver","scrollCb","evt","defaultView","scrollLeftTop","scroll","INPUT_TAGS","lastInputValueMap","initInputObserver","_ref10","inputCb","ignoreClass","ignoreSelector","userTriggeredOnInput","eventHandler","userTriggered","isTrusted","isChecked","cbWithDedup","querySelectorAll","v","lastInputValue","currentWindow","propertyDescriptor","HTMLInputElement","hookProperties","HTMLSelectElement","HTMLTextAreaElement","HTMLOptionElement","p","getNestedCSSRulePositions","childRule","hasNestedCSSRule","parentRule","CSSGroupingRule","CSSMediaRule","CSSSupportsRule","CSSConditionRule","unshift","parentStyleSheet","recurse","getIdAndStyleId","styleMirror","styleId","ownerNode","initAdoptedStyleSheetObserver","_ref17","hostId","patchTarget","ShadowRoot","originalPropertyDescriptor","configurable","_this6","sheets","_this7","_15","_16","adoptStyleSheets","initObservers","o","_ref9","viewportResizeCb","lastH","lastW","_step4","mutationObserver","mousemoveHandler","mousemoveCb","mousemove","timeBaseline","callbackThreshold","mousemoveCallback","positions","wrappedCb","totalOffset","timeOffset","updatePosition","DragEvent","Drag","MouseEvent","MouseMove","TouchMove","initMoveObserver","mouseInteractionHandler","scrollHandler","viewportResizeHandler","inputHandler","mediaInteractionHandler","_ref20","mediaInteractionCb","volume","muted","playbackRate","initMediaInteractionObserver","styleSheetObserver","_ref11","_ref12","styleSheetRuleCb","CSSStyleSheet","insertRule","thisArg","argumentsList","_argumentsList","_getIdAndStyleId","replaceSync","deleteRule","_getIdAndStyleId2","_getIdAndStyleId3","_getIdAndStyleId4","supportedNestedCSSRuleTypes","canMonkeyPatchNestedCSSRule","unmodifiedFunctions","_ref13","_ref14","typeKey","_argumentsList5","_getIdAndStyleId5","_getIdAndStyleId6","_ref15","_ref16","initStyleSheetObserver","adoptedStyleSheetObserver","styleDeclarationObserver","_ref18","_ref19","styleDeclarationCb","ignoreCSSAttributes","setProperty","CSSStyleDeclaration","_argumentsList7","priority","_getIdAndStyleId7","_17","removeProperty","_getIdAndStyleId8","initStyleDeclarationObserver","fontObserver","collectFonts","_ref21","fontCb","fontMap","originalFontFace","FontFace","family","descriptors","fontFace","fontSource","Uint8Array","restoreHandler","fonts","initFontObserver","selectionObserver","param","selectionCb","collapsed","updateSelection","selection","getSelection","isCollapsed","ranges","rangeCount","range","getRangeAt","startContainer","startOffset","endContainer","endOffset","initSelectionObserver","customElementObserver","_ref22","customElementCb","define","initCustomElementObserver","pluginHandlers","_iterator4","plugins","plugin","CrossOriginIframeMirror","generateIdFn","iframeIdToRemoteIdMap","iframeRemoteIdToIdMap","remoteId","idToRemoteMap","remoteToIdMap","idToRemoteIdMap","getIdToRemoteIdMap","remoteIdToIdMap","getRemoteIdToIdMap","_this8","ids","_this9","getRemoteId","_optionalChain$1","_value7","_len7","_key7","wrappedEmit","_takeFullSnapshot","IframeManagerNoop","crossOriginIframeMirror","crossOriginIframeRootIdMap","IframeManager","iframes","crossOriginIframeMap","recordCrossOriginIframes","crossOriginIframeStyleMirror","generateId","handleMessage","loadListener","isAttachIframe","adoptedStyleSheets","crossOriginMessageEvent","transformedEvent","transformCrossOriginEvent","isCheckout","_this10","FullSnapshot","replaceIdOnNode","patchRootIdOnNode","IncrementalSnapshot","Mutation","Meta","Load","DomContentLoaded","Plugin","Custom","replaceIds","ViewportResize","MediaInteraction","MouseInteraction","Scroll","CanvasMutation","Input","StyleSheetRule","StyleDeclaration","replaceStyleIds","Font","Selection","AdoptedStyleSheet","styles","iframeMirror","_step5","_iterator5","getIds","_this11","child","_this12","ShadowDomManagerNoop","ShadowDomManager","shadowDoms","WeakSet","restoreHandlers","patchAttachShadow","_this13","iframeElement","manager","option","CanvasManagerNoop","StylesheetManager","trackedLinkElements","adoptedStyleSheetCb","linkEl","trackStylesheetInLinkElement","_step6","adoptedStyleSheetData","styleIds","_iterator6","CSSRule","ProcessedNodeManager","nodeMap","loop","periodicallyClear","_this14","onRequestAnimationFrame","clear","thisBuffer","buffers","record","checkoutEveryNms","checkoutEveryNth","_options$blockClass","_options$blockSelecto","_options$unblockSelec","_options$ignoreClass","_options$ignoreSelect","_options$maskAllText","_options$maskTextClas","_options$unmaskTextCl","_options$maskTextSele","_options$unmaskTextSe","_options$inlineStyles2","maskAllInputs","_maskInputOptions","_slimDOMOptions","_options$maxCanvasSiz","maxCanvasSize","packFn","_options$sampling","_options$dataURLOptio4","mousemoveWait","_options$recordCanvas2","_options$recordCrossO","_options$recordAfter","recordAfter","_options$userTriggere","_options$collectFonts","_options$inlineImages2","_options$keepIframeSr2","_options$ignoreCSSAtt","getCanvasManager","inEmittingFrame","parent","passEmitsToParent","lastFullSnapshotEvent","color","date","month","number","search","tel","week","select","radio","checkbox","_this3","NodeList","DOMTokenList","_len4","_key4","TypeError","polyfill","incrementalSnapshotCount","eventProcessor","_step7","_iterator7","_optionalChain","isFrozen","buf","postMessage","exceedCount","exceedTime","takeFullSnapshot","_step8","wrappedMutationEmit","wrappedScrollEmit","wrappedCanvasMutationEmit","__RRWEB_EXCLUDE_IFRAME__","_iterator8","getMirror","nodeMirror","getCanvasManagerFn","_getCanvasManager","__RRWEB_EXCLUDE_SHADOW_DOM__","_ref3$mirror","_ref3$blockClass","_ref3$blockSelector","_ref3$unblockSelector","_ref3$maskAllText","_ref3$maskTextClass","_ref3$unmaskTextClass","_ref3$maskTextSelecto","_ref3$unmaskTextSelec","_ref3$inlineStyleshee","_ref3$inlineImages","_ref3$recordCanvas","_ref3$maskAllInputs","_ref3$slimDOM","slimDOM","_ref3$keepIframeSrcFn","snapshot","initialOffset","canvasMutationCb","CustomElement","addLoadListener","destroy","timestampToMs","timestampToS","addBreadcrumbEvent","replay","triggerUserActivity","checkAndHandleExpiredSession","addUpdate","throttledAddEvent","tag","normalize","getClosestInteractive","closest","getClickTargetNode","getTargetNode","isEventWithTarget","onWindowOpen","originalWindowOpen","_len8","_key8","ClickDetector","slowClickConfig","_addBreadcrumbEvent","_lastMutation","_lastScroll","_clicks","_timeout","_threshold","_scollTimeout","scrollTimeout","_replay","_ignoreSelector","_this15","cleanupWindowOpen","nowInSeconds","_teardown","_checkClickTimeout","SLOW_CLICK_TAGS","ignoreElement","isClickBreadcrumb","newClick","clickBreadcrumb","clickCount","_scheduleCheckClicks","_handleMultiClick","_getClicks","_this16","timedOutClicks","mutationAfter","scrollAfter","_i5","_timedOutClicks","_generateBreadcrumbs","hadScroll","hadMutation","isSlowClick","timeAfterClickMs","endReason","route","getCurrentRoute","_this17","_checkClicks","updateClickDetectorForRecordingEvent","clickDetector","isIncrementalEvent","registerMutation","registerScroll","isIncrementalMouseInteraction","_event$data","HTMLElement","registerClick","createBreadcrumb","ATTRIBUTES_TO_RECORD","getAttributesToRecord","normalizedKey","handleDomListener","isEnabled","_getDomTarget","isClick","getDomTarget","getBaseDomBreadcrumb","handleDom","altKey","metaKey","ctrlKey","shiftKey","handleClick","isElement","handleKeyboardEvent","updateUserActivity","isContentEditable","isInputElement","hasModifierKey","isCharacterKey","baseBreadcrumb","getKeyboardBreadcrumb","ENTRY_TYPES","resource","decodedBodySize","encodedBodySize","responseStatus","transferSize","getAbsoluteTime","paint","navigation","domComplete","domContentLoadedEventStart","domContentLoadedEventEnd","domInteractive","loadEventStart","loadEventEnd","redirectCount","createPerformanceEntry","setupPerformanceObserver","addPerformanceEntry","onEntries","_ref23","clearCallbacks","_ref24","replayPerformanceEntries","getLargestContentfulPaint","clearCallback","logInfo","shouldAddBreadcrumb","info","addLogBreadcrumb","logInfoNextTick","EventBufferSizeExceededError","EventBufferArray","events","_totalSize","hasCheckout","_addEvent2","eventSize","_this18","eventsRet","WorkerHandler","worker","_worker","_this19","_ensureReadyPromise","_ref25","success","terminate","arg","_this20","_getAndIncrementId","_ref26","EventBufferCompressionWorker","_earliestTimestamp","ensureReady","_sendEventToWorker","_finishRequest","_finishRequest2","_context3","sent","EventBufferProxy","_fallback","_compression","_used","_ensureWorkerIsLoadedPromise","_ensureWorkerIsLoaded","hasEvents","getEarliestTimestamp","addEvent","_finish","_callee3","_context4","ensureWorkerIsLoaded","finish","_ensureWorkerIsLoaded2","_callee4","_context5","t0","_switchToCompressionWorker","_switchToCompressionWorker2","_callee5","_this$_fallback","addEventPromises","_iterator9","_step9","_context6","all","createEventBuffer","_ref27","useCompression","customWorkerUrl","workerUrl","Worker","__SENTRY_EXCLUDE_REPLAY_WORKER__","Blob","URL","createObjectURL","_getWorkerUrl","_loadWorker","hasSessionStorage","sessionStorage","clearSession","removeItem","deleteSession","isSampled","started","lastActivity","segmentId","previousSessionId","saveSession","setItem","createSession","_ref28","sessionSampleRate","allowBuffering","_ref28$stickySession","stickySession","getSessionSampleType","isExpired","initialTime","expiry","targetTime","isSessionExpired","_ref30","maxReplayDuration","sessionIdleExpire","_ref30$targetTime","shouldRefreshSession","_ref31","loadOrCreateSession","_ref32","sessionOptions","traceInternals","existingSession","sessionStringFromStorage","getItem","sessionObj","parse","fetchSession","addEventSync","shouldAddEvent","_addEvent","_x3","_x4","_addEvent3","_callee11","replayOptions","eventAfterPossibleCallback","_context12","eventBuffer","recordingMode","maybeApplyCallback","beforeAddRecordingEvent","isPaused","timestampInMs","timeouts","sessionIdlePause","initialTimestamp","_experiments","isCustomEvent","isTransactionEvent","isFeedbackEvent","handleAfterSendEvent","enforceStatusCode","isBaseTransportSend","sendResponse","replayContext","trace","trace_id","traceIds","handleTransactionEvent","errorIds","_replay$getOptions","beforeErrorSampling","sendBufferedReplayOrFlush","handleErrorEvent","handleBeforeSendEvent","exceptionValue","handleHydrationError","handleGlobalEventListener","afterSendHandler","isReplayEvent","feedback","getSessionId","feedbackId","addFeedbackBreadcrumb","__rrweb__","isRrwebError","captureExceptions","isErrorEventSampled","errorSampleRate","shouldSampleForBufferEvent","createPerformanceSpans","_ref33","handleHistorySpanListener","handleHistory","urls","addNetworkBreadcrumb","isSentryRequestUrl","shouldFilterRequest","handleXhrSpanListener","handleXhr","getBodySize","encode","URLSearchParams","FormData","formDataStr","_serializeFormData","ArrayBuffer","byteLength","parseContentLengthHeader","header","parseInt","getBodyString","mergeWarning","warning","_meta","warnings","newMeta","existingWarnings","makeNetworkReplayBreadcrumb","request","buildSkippedNetworkRequestOrResponse","bodySize","buildNetworkRequestOrResponse","_normalizeNetworkBody","exceedsSizeLimit","isProbablyJson","first","last","truncatedBody","e3","normalizeNetworkBody","normalizedBody","getAllowedHeaders","allowedHeaders","reduce","filteredHeaders","formData","urlMatches","fullUrl","baseURI","fixedUrl","getFullUrl","stringMatchesSomePattern","_captureFetchBreadcrumbToReplay","_callee12","_context13","_prepareFetchData","_x8","_x9","_x10","_prepareFetchData2","_callee13","_hint$startTimestamp2","_hint$endTimestamp2","_breadcrumb$data2","_breadcrumb$data2$sta","requestBodySize","responseBodySize","captureDetails","_context14","request_body_size","response_body_size","networkDetailAllowUrls","networkDetailDenyUrls","_getRequestInfo","_getResponseInfo","_ref34","networkCaptureBodies","networkRequestHeaders","fetchArgs","getHeadersFromOptions","getRequestHeaders","_getBodyString2","_getFetchRequestArgBody","bodyStr","_x11","_x12","_x13","_x14","_getResponseInfo2","_callee14","_ref35","networkResponseHeaders","_yield$_parseFetchRes","_yield$_parseFetchRes2","bodyText","_context15","getAllHeaders","_parseFetchResponseBody","getResponseData","_ref36","_x15","_parseFetchResponseBody2","_callee15","_context16","_tryCloneResponse","_tryGetResponseText","allHeaders","Headers","_x16","_getResponseText2","_getResponseText","txt","_callee16","_context17","_captureXhrBreadcrumbToReplay","_callee17","_context18","_prepareXhrData","enrichXhrBreadcrumb","reqSize","resSize","getResponseHeader","responseType","_getBodySize","_hint$startTimestamp","_hint$endTimestamp","_breadcrumb$data","_breadcrumb$data$stat","xhrInfo","request_headers","getAllResponseHeaders","acc","line","_line$split2","getResponseHeaders","_ref38","requestBody","requestWarning","_ref39","errors","responseText","outerHTML","_parseXhrResponse","_getXhrResponseBody","_ref40","responseBody","responseWarning","handleNetworkBreadcrumbs","TextEncoder","_replay$getOptions2","_isXhrBreadcrumb","_isXhrHint","_x17","_x18","_x19","captureXhrBreadcrumbToReplay","_isFetchBreadcrumb","_isFetchHint","enrichFetchBreadcrumb","_x5","_x6","_x7","captureFetchBreadcrumbToReplay","beforeAddNetworkBreadcrumb","handleFetch","handleFetchSpanListener","_LAST_BREADCRUMB","handleScopeListener","newBreadcrumb","getLastBreadcrumb","isBreadcrumbWithCategory","isTruncated","normalizedArgs","normalizedArg","normalizeConsoleBreadcrumb","handleScope","hasHooks","addMemoryEntry","_x20","_addMemoryEntry","_callee18","_context19","memoryEntry","memory","jsHeapSizeLimit","totalJSHeapSize","usedJSHeapSize","getHandleRecordingEmit","hadFirstEvent","_isCheckout","setInitialState","shouldRecordCanvas","isRecordingCanvas","useCompressionOption","blockAllMedia","networkDetailHasUrls","networkRequestHasHeaders","networkResponseHasHeaders","createOptionsEvent","addSettingsEvent","earliestEvent","createReplayEnvelope","replayEvent","recordingData","createEventEnvelopeHeaders","getSdkMetadataForEnvelopeHeader","prepareRecordingData","_ref41","payloadWithSequence","replayHeaders","sequence","prepareReplayEvent","_x21","_prepareReplayEvent","_callee19","_ref42","integrations","eventHint","preparedEvent","metadata","_ref52","_context20","_integrations","prepareEvent","platform","getSdkMetadata","sendReplayRequest","_x22","_sendReplayRequest","_callee20","_ref43","segment_id","eventContext","preparedRecordingData","baseEvent","_context21","replay_start_timestamp","error_ids","trace_ids","replay_type","cause","TransportStatusCodeError","RateLimitError","_Error2","_Error3","_this21","sendReplay","_x23","_sendReplay","_callee22","replayData","retryConfig","_args22","_context23","interval","_retryCount","_callee21","_context22","THROTTLED","throttle","maxCount","durationSeconds","isThrottled","_cleanup","wasThrottled","ReplayContainer","_ref44","_this22","recordingOptions","__init","__init2","__init3","__init4","__init5","__init6","_lastActivity","_isEnabled","_isPaused","_hasInitializedCoreListeners","initialUrl","_recordingOptions","_debouncedFlush","callbackReturnValue","timerId","maxTimerId","maxWait","invokeFunc","cancelTimers","debounced","cancel","debounce","flushMinDelay","flushMaxDelay","_throttledAddEvent","_this$getOptions","slowClickTimeout","slowClickIgnoreSelectors","_canvas","_this$_options","_initializeSessionForSampling","_initializeRecording","_handleException","_updateUserActivity","canvasOptions","_stopRecording","_onMutationHandler","_stop","_callee6","_ref45","_ref45$forceFlush","forceFlush","_args6","_context7","_removeListeners","stopRecording","force","_checkSession","startRecording","_sendBufferedReplayOrFlush","_callee7","_ref46$continueRecord","continueRecording","activityTime","hasStoppedRecording","_args7","_context8","flushImmediate","_updateSessionActivity","_maybeSaveSession","cbResult","resume","pause","urlPath","pathname","hash","_clearContext","_this23","lastTransaction","getTransaction","SEMANTIC_ATTRIBUTE_SENTRY_SOURCE","_addListeners","_refreshSession","_refreshSession2","_callee8","_context9","initializeSampling","_x24","_handleVisibilityChange","_handleWindowBlur","_handleWindowFocus","_handleKeyboardEvent","addListeners","addScopeListener","addEventProcessor","dsc","feedbackEvent","includeReplay","addGlobalListeners","_performanceCleanupCallback","removeListeners","_this24","visibilityState","_doChangeToForegroundTasks","_doChangeToBackgroundTasks","_this25","_this26","_this27","_createCustomBreadcrumb","conditionalFlush","_this28","_runFlush2","_callee9","_context10","_addPerformanceEntries","_updateInitialTimestampFromEventBuffer","_popEventContext","_this29","_callee10","_ref48$force","tooShort","tooLong","_args10","_context11","minReplayDuration","_flushLock","_runFlush","_this30","mutationLimit","overMutationLimit","mutationBreadcrumbLimit","getOption","selectors","defaultSelectors","deprecatedClassOption","deprecatedSelectorOption","deprecatedSelectors","allSelectors","MEDIA_SELECTORS","DEFAULT_NETWORK_HEADERS","_initialized","replayIntegration$1","Replay$1","_ref51","_ref51$flushMinDelay","_ref51$flushMaxDelay","_ref51$minReplayDurat","_ref51$maxReplayDurat","_ref51$stickySession","_ref51$useCompression","_ref51$_experiments","_ref51$maskAllText","_ref51$maskAllInputs","_ref51$blockAllMedia","_ref51$mutationBreadc","_ref51$mutationLimit","_ref51$slowClickTimeo","_ref51$slowClickIgnor","_ref51$networkDetailA","_ref51$networkDetailD","_ref51$networkCapture","_ref51$networkRequest","_ref51$networkRespons","_ref51$mask","mask","_ref51$maskAttributes","maskAttributes","_ref51$unmask","unmask","_ref51$block","block","_ref51$unblock","unblock","_ref51$ignore","ignore","maskFn","privacyOptions","_ref49","getPrivacyOptions","password","_ref50","maskAttribute","_initialOptions","_getMergedNetworkHeaders","_isInitialized","isBrowser","_this31","_setup","_initialize","startBuffering","_maybeLoadFromReplayCanvasIntegration","finalOptions","initialOptions","opt","replaysSessionSampleRate","replaysOnErrorSampleRate","loadReplayOptionsFromClient","canvasIntegration","getIntegrationByName","getReplay$1","__initStatic","hubOrClient","isHub","checkDsn","removeTrailingSlash","checkTunnel","Transaction","_Span","_hub","_name","_trimEnd","trimEnd","incomingDynamicSamplingContext","dynamicSamplingContext","_frozenDynamicSamplingContext","newName","setName","spanMetadata","_attributes","SEMANTIC_ATTRIBUTE_SENTRY_SAMPLE_RATE","maxlen","spanRecorder","SpanRecorder","newMetadata","timestampInS","spanTimeInputToSeconds","_finishTransaction","spanContext","_superPropGet","getDynamicSamplingContextFromSpan","_endTime","_sampled","finishedSpans","endTimes","_getCapturedScopesOnS","getCapturedScopesOnSpan","capturedSpanScope","capturedSpanIsolationScope","spanToTraceContext","_startTime","_metrics_summary","transaction_info","getBucketKey","stringifiedTags","localeCompare","simpleHash","rv","charCodeAt","serializeMetricBuckets","metricBucketItems","out","tagEntries","maybeTags","sanitizeUnit","sanitizeMetricKey","sanitizeTagKey","tagValueReplacements","sanitizeTagValue","char","getCharOrReplacement","sanitizeTags","unsanitizedTags","hasOwnProperty","cachedFetchImpl","makeFetchTransport","nativeFetch","isNativeFetch","fetchImpl","getNativeFetchImplementation","pendingBodySize","pendingCount","requestSize","requestOptions","referrerPolicy","keepalive","fetchOptions","createUserFeedbackEnvelope","createUserFeedbackEnvelopeItem","_maxlen","_traceId","_spanId","instrumenter","setAttributes","SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN","SEMANTIC_ATTRIBUTE_SENTRY_OP","parentSpanId","_parentSpanId","_status","_exclusiveTime","updateName","string","endTime","traceFlags","TRACE_FLAG_SAMPLED","TRACE_FLAG_NONE","childSpan","rootSpan","getRootSpan","opStr","nameStr","idStr","logMessage","_logMessage","spanToTraceHeader","_getData","parent_span_id","span_id","SEMANTIC_ATTRIBUTE_PROFILE_ID","exclusive_time","getSpanJSON","hasData","hasAttributes","DEFAULT_BROWSER_TRACING_OPTIONS","TRACING_DEFAULTS","instrumentNavigation","instrumentPageLoad","markBackgroundSpan","enableLongTask","enableInp","defaultRequestInstrumentationOptions","browserTracingIntegration","_hasSetTracePropagationTargets","tracePropagationTargets","tracingOrigins","addTracingExtensions","_collectWebVitals","enableInteractions","latestRoute","_createRouteTransaction","expandedContext","beforeStartSpan","idleTimeout","finalTimeout","heartbeatInterval","isPageloadTransaction","sentryTrace","getMetaContent","baggage","_propagationContextFr","propagationContextFromHeaders","finalContext","idleTransaction","startIdleTransaction","sendAutoFinishSignal","registerBeforeFinishCallback","afterAllSetup","activeSpan","clientOptions","traceFetch","traceXHR","shouldCreateSpanForRequest","enableHTTPTimings","clientOptionsTracePropagationTargets","startingUrl","startBrowserTracingPageLoadSpan","startBrowserTracingNavigationSpan","registerBackgroundTabDetection","inflightInteractionTransaction","registerInteractionTransaction","currentTransaction","setFinishReason","getSource","registerInteractionListener","getReplayId","isPerformanceEventTiming","minInteractionId","MAX_INTERACTIONS","registerInpInteractionListener","instrumentOutgoingRequests","spanOptions","metaName","metaTag","getDomElement","sourceFromAttributes","sourceFromData","sourceFromMetadata","getGlobalObject","supportsFetch","Request","Response","supportsNativeFetch","EdgeRuntime","supportsReportingObserver","defaultIntegrations","inboundFiltersIntegration","functionToStringIntegration","browserApiErrorsIntegration","globalHandlersIntegration","linkedErrorsIntegration","dedupeIntegration","httpContextIntegration","getDefaultIntegrations","__SENTRY_RELEASE__","SENTRY_RELEASE","autoSessionTracking","sendClientReports","stackParserFromStackParserOptions","defaultStackParser","getIntegrationsToSetup","makeXHRTransport","initAndBind","BrowserClient","ignoreDuration","startSessionTracking","showReportDialog","_hub$getStackTop","async","onLoad","onload","onClose","reportDialogClosedMessageHandler","injectionPoint","forceLoad","wrap$1","captureUserFeedback","isGlobalObj","globalThis","self","creator","gbl","DSN_REGEX","withPassword","pass","dsnFromString","_match$slice2","_match$slice2$","_match$slice2$2","projectMatch","dsnFromComponents","components","component","isValidProtocol","validateDsn","installedIntegrations","userIntegrations","isDefaultInstance","finalIntegrations","integrationsByName","currentInstance","existingInstance","k","filterDuplicates","arrayify","debugIndex","arr","findIndex","debugInstance","integrationIndex","setupIntegration","afterSetupIntegrations","preprocessEvent","processEvent","addIntegration","applyAggregateErrorsToEvent","exceptionFromErrorImplementation","parser","maxValueLimit","isInstanceOf","exceptions","maxValueLength","aggregateExceptionsFromError","truncate","prevExceptions","exceptionId","newExceptions","applyExceptionGroupFieldsForParentException","newException","newExceptionId","applyExceptionGroupFieldsForChildException","childError","mechanism","handled","is_exception_group","exception_id","parent_id","originalFunctionToString","SETUP_CLIENTS","Function","originalFunction","getOriginalFunction","FunctionToString","instrumentFetchRequest","shouldCreateSpan","shouldAttachHeaders","spanOrigin","shouldCreateSpanResult","_handlerData$fetchDat","getFullURL","startInactiveSpan","onlyIfParent","__span","requestSpan","getSpan","_isolationScope$getPr","getPropagationContext","sentryTraceHeader","generateSentryTraceHeader","sentryBaggageHeader","dynamicSamplingContextToSentryBaggageHeader","getDynamicSamplingContextFromClient","newHeaders","append","BAGGAGE_HEADER_NAME","existingBaggageHeader","newBaggageHeaders","addTracingHeadersToFetchRequest","contentLength","contentLengthNum","endSpan","DEFAULT_TRACE_PROPAGATION_TARGETS","_traceFetch$traceXHR$","shouldAttachHeadersWithTargets","createdSpan","addHTTPTimings","__sentry_own_request__","__sentry_xhr_span_id__","setRequestHeader","setHeaderOnXhr","xhrCallback","cleanup","nextHopProtocol","isPerformanceResourceTiming","resourceTiming","_extractNetworkProtoc","_nextHopProtocol$spli2","extractNetworkProtocol","timingSpanData","redirectStart","fetchStart","domainLookupStart","domainLookupEnd","connectStart","secureConnectionStart","connectEnd","resourceTimingEntryToSpanData","isNodeEnv","process","clientClass","debug","enable","update","initialScope","setCurrentClient","initializeClient","snipLine","colno","newLine","lineLength","delimiter","isVueViewModel","testString","requireExactStringMatch","pattern","isString","isRegExp","isMatchingPattern","public_key","user_segment","txn","v7FrozenDsc","_txn$metadata","maybeSampleRate","sample_rate","jsonSpan","spanIsSampled","_span$spanContext","_span$spanContext2","ensureTimestampInSeconds","spanIsSpanClass","toJSON","DEFAULT_EVENT_TARGET","XMLHttpRequest","eventTarget","requestAnimationFrame","setInterval","_wrapTimeFunction","_wrapRAF","_wrapXHR","eventTargetOption","_wrapEventTarget","TryCatch","originalCallback","function","originalSend","wrapOptions","globalObject","proto","handleEvent","originalRemoveEventListener","wrappedEventHandler","originalEventHandler","__sentry_wrapped__","SENTRY_BAGGAGE_KEY_PREFIX","SENTRY_BAGGAGE_KEY_PREFIX_REGEX","MAX_BAGGAGE_STRING_LENGTH","baggageHeaderToDynamicSamplingContext","baggageHeader","baggageObject","curr","currBaggageObject","baggageHeaderToObject","_Object$keys","object","currentIndex","_ref8","objectKey","objectValue","baggageEntry","newBaggageHeader","objectToBaggageHeader","dscKey","dscValue","keyOrValue","decodeURIComponent","isBrowserBundle","onerror","onunhandledrejection","stackTraceLimit","addGlobalErrorInstrumentationHandler","_getOptions","shouldIgnoreOnError","msg","column","ERROR_TYPES_RE","groups","_enhanceEventWithInitialFrame","_eventFromIncompleteOnError","_installGlobalOnErrorHandler","globalHandlerLog","addGlobalUnhandledRejectionInstrumentationHandler","_getOptions2","isPrimitive","detail","_getUnhandledRejectionError","_installGlobalOnUnhandledRejectionHandler","GlobalHandlers","ev","ev0","ev0s","ev0sf","lineno","filename","getLocationHref","in_app","handleCallbackErrors","onError","onFinally","maybeHandlePromiseRejection","afterFinish","parentSpan","normalizeContext","createChildSpanOrTransaction","forceTransaction","startSpan","startSpanManual","finishAndSetSpan","isRecording","temporaryScope","continueTrace","_tracingContextFromHe","tracingContextFromHeaders","traceparentData","setPropagationContext","_parentSpan$spanConte","addNonEnumerableProperty","ISOLATION_SCOPE_ON_START_SPAN_FIELD","SCOPE_ON_START_SPAN_FIELD","setCapturedScopesOnSpan","XHR_READYSTATE_DONE","onreadystatechange","open","referrer","Referer","HttpContext","onHiddenOrPageHide","startingTime","sid","did","abnormal_mechanism","attrs","ipAddress","user_agent","sessionToJSON","lastHref","instrumentHistory","chromeVar","chrome","isChromePackagedApp","app","runtime","hasHistoryApi","pushState","replaceState","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","maybeHub","extractTraceparentData","extractTraceparentData$1","STACKTRACE_FRAME_LIMIT","WEBPACK_ERROR_REGEXP","STRIP_FRAME_REGEXP","createStackParser","parsers","sortedParsers","skipFirst","lines","cleanedLine","frame","localStack","reverse","stripSentryFramesAndReverse","defaultFunctionName","DEFAULT_IGNORE_ERRORS","DEFAULT_IGNORE_TRANSACTIONS","_hint","mergedOptions","internalOptions","allowUrls","denyUrls","ignoreErrors","disableErrorDefaults","ignoreTransactions","disableTransactionDefaults","ignoreInternal","_mergeOptions","_isSentryError","lastException","possibleMessages","_getPossibleEventMessages","_isIgnoredError","_isIgnoredTransaction","_getEventFilterUrl","_isDeniedUrl","_isAllowedUrl","_shouldDropEvent","InboundFilters","_getLastValidUrl","oO","instrumentXHR","xhrproto","originalOpen","onreadystatechangeHandler","readyStateArgs","setRequestHeaderArgs","States","executor","_state","PENDING","_handlers","_resolve","_reject","onfulfilled","onrejected","_executeHandlers","val","onfinally","isRejected","_setResult","RESOLVED","REJECTED","state","cachedHandlers","__WEB_VITALS_POLYFILL__","getEntriesByType","navigationEntry","getNavigationEntryFromPerformanceTiming","_oldOnErrorHandler","instrumentError","__SENTRY_LOADER__","__SENTRY_INSTRUMENTED__","UNKNOWN_FUNCTION","createFrame","chromeRegex","chromeEvalRegex","chromeStackLineParser","subMatch","_extractSafariExtensi2","extractSafariExtensionDetails","geckoREgex","geckoEvalRegex","geckoStackLineParser","_extractSafariExtensi4","winjsRegex","winjsStackLineParser","opera10Regex","opera10StackLineParser","opera11Regex","opera11StackLineParser","defaultStackLineParsers","isSafariExtension","isSafariWebExtension","query","fragment","stripUrlQueryAndFragment","_options$normalizeDep","_options$normalizeMax","normalizeMaxBreadth","prepared","dist","_options$maxValueLeng","applyClientOptions","integrationNames","applyIntegrationsMetadata","debugIdStackFramesCache","debugIdMap","_sentryDebugIds","cachedDebugIdStackFrameCache","debugIdStackParserCache","filenameDebugIdMap","debugIdStackTrace","parsedStack","cachedParsedStack","stackFrame","debug_id","applyDebugIds","finalScope","getFinalScope","clientEventProcessors","getEventProcessors","isolationData","mergeScopeData","finalScopeData","abs_path","debug_meta","images","code_file","applyDebugMeta","depth","maxBreadth","normalized","normalizeEvent","hintIsScopeOrFunction","captureContextKeys","hintIsScopeContext","createMetricEnvelope","createMetricEnvelopeItem","ALREADY_SEEN_ERROR","BaseClient","_integrationsInitialized","_numProcessing","_outcomes","_hooks","_dsn","_transport","transportOptions","checkOrSetAlreadyCaught","_process","_captureEvent","eventMessage","promisedEvent","sendSession","metricsAggregator","_isClientDoneProcessing","clientFinished","transportFlushed","enabled","forceInitialize","_setupIntegrations","integrationId","integrationName","isAlreadyInstalled","env","createEventEnvelope","addItemToEnvelope","createAttachmentEnvelopeItem","promise","_sendEnvelope","createSessionEnvelope","eventOrCount","metricsEnvelope","hook","crashed","errored","sessionNonTerminal","ticked","clearInterval","_processEvent","finalEvent","sentryError","isTransaction","eventType","beforeSendLabel","_prepareEvent","__sentry__","beforeSend","beforeSendTransaction","spanCountBefore","spanCountBeforeProcessing","processBeforeSend","beforeSendResult","invalidValueError","_validateBeforeSendResult","processedEvent","spanCount","_updateSessionFromEvent","droppedSpanCount","transactionInfo","sendEvent","outcomes","_key$split2","quantity","DEFAULT_MAX_STRING_LENGTH","elem","nextStr","currentElem","_htmlElementAsString","separator","classes","dataset","keyAttrPairs","keyAttr","keyAttrPair","allowedAttrs","querySelector","replacementFactory","markFunctionWrapped","writable","o_O","__sentry_original__","convertToPlainObject","getOwnProperties","newObj","serializeEventTarget","currentTarget","CustomEvent","extractedProps","maxLength","includedKeys","serialized","inputValue","_dropUndefinedKeys","memoizationMap","isPojo","memoVal","returnValue","TRACEPARENT_REGEXP","traceparent","sampledString","errorsInstrumented","errorCallback","traceHeaders","_startTransaction","configInstrumenter","transactionInstrumenter","sampleTransaction","initSpanRecorder","maxSpans","onScope","delayAutoFinishUntilSignal","IdleTransaction","debounceTimerID","lastCapturedEventType","lastCapturedEventTargetId","DEBOUNCE_DURATION","instrumentDOM","triggerDOMHandler","globalDOMEventHandler","makeDOMEventHandler","originalAddEventListener","__sentry_instrumentation_handlers__","handlerForType","refCount","globalListener","shouldSkipDOMEvent","_sentryId","isSimilarToLastCapturedEvent","newItem","_envelope","envelopeItem","envelopeContainsItemType","types","encodeUTF8","_envelope2","envHeaders","_item","itemHeaders","stringifiedPayload","totalLength","merged","offset","concatBuffers","parseEnvelope","textDecoder","readBinary","bin","subarray","readJson","decode","envelopeHeader","itemHeader","binaryLength","content_type","contentType","attachment_type","attachmentType","ITEM_TYPE_TO_DATA_CATEGORY_MAP","sessions","client_report","user_report","profile","replay_event","replay_recording","check_in","statsd","metadataOrEvent","_metadataOrEvent$sdk","DEFAULT_RETRY_AFTER","parseRetryAfterHeader","headerDelay","headerDate","limits","disabledUntil","updatedRateLimits","rateLimitHeader","retryAfterHeader","_limit$split2","retryAfter","categories","namespaces","delay","cleanedExtra","cleanedTags","cleanedUser","cleanedContexts","applyDataToEvent","applySpanToEvent","applyFingerprintToEvent","mergedBreadcrumbs","applyBreadcrumbsToEvent","applySdkMetadataToEvent","mergeData","mergeAndOverwriteScopeData","mergeVal","timeStamp","crypto","msCrypto","getRandomByte","randomUUID","getRandomValues","typedArray","getFirstException","firstException","newMechanism","currentMechanism","mergedData","addContextToFrame","linesOfContext","maxLines","sourceLine","pre_context","context_line","post_context","__sentry_captured__","maybeArray","_oldOnUnhandledRejectionHandler","instrumentUnhandledRejection","ignoreOnError","before","wrapper","sentryWrapped","wrappedArguments","previousEvent","currentEvent","currentMessage","previousMessage","_isSameFingerprint","_isSameStacktrace","_isSameMessageEvent","previousException","_getExceptionFromEvent","currentException","_isSameExceptionEvent","Dedupe","currentFrames","_getFramesFromEvent","previousFrames","frameA","frameB","currentFingerprint","previousFingerprint","envelopeHeaders","packages","enhanceEventWithSdkInfo","eventItem","objectToString","wat","isBuiltin","Event","isSyntheticEvent","base","_e","__isVue","_isVue","maxProperties","visit","ERROR","maxSize","encodeURI","utf8Length","hasWeakSet","inner","memo","_memo","memoize","unmemoize","stringified","_events","objName","getConstructorName","stringifyValue","remainingDepth","valueWithToJSON","numAdded","visitable","visitKey","visitValue","LinkedErrors","__SENTRY_BROWSER_BUNDLE__","getSDKSource","IDLE_TRANSACTION_FINISH_REASONS","IdleTransactionSpanRecorder","_SpanRecorder","_pushActivity","_popActivity","transactionSpanId","originalEnd","_Transaction","_idleHub","_idleTimeout","_finalTimeout","_heartbeatInterval","_onScope","activities","_heartbeatCounter","_finished","_idleTimeoutCanceledPermanently","_beforeFinishCallbacks","_finishReason","_autoFinishAllowed","_restartIdleTimeout","endTimestampInS","spanStartedBeforeTransactionFinish","timeoutWithMarginOfError","spanEndedBeforeFinalTimeout","stringifiedSpan","_pingHeartbeat","restartOnChildSpanChange","_idleTimeoutID","cancelIdleTimeout","heartbeatString","_prevHeartbeatString","_beat","instrumentFetch","originalFetch","_parseFetchArgs","_fetchArgs","getUrlFromResource","hasProp","parseFetchArgs","finishedHandlerData","erroredHandlerData","wrappedFuncs","wrappedLevels","disable","_GLOBAL_OBJ$console","makeLogger","statusType","samplingContext","rate","createClientReportEnvelope","discarded_events","clientReportItem","_BaseClient","names","applySdkMetadata","SENTRY_SDK_SOURCE","_flushOutcomes","_clearOutcomes"],"sourceRoot":""}