{"version":3,"file":"927be6b0fc860b24b89c.bundle.js","mappings":"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","sources":["webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/debug-build.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/getNativeImplementation.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/instrument/dom.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/instrument/history.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/instrument/xhr.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/browserMetrics.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/cls.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/inp.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/bindReporter.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/initMetric.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/generateUniqueID.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/observe.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/runOnce.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/whenActivated.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/onFCP.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/getCLS.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/getFID.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/polyfills/interactionCountPolyfill.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/interactions.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/whenIdle.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/getINP.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/getLCP.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/onTTFB.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/instrument.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/utils.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/getActivationStart.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/getNavigationEntry.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/getVisibilityWatcher.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/metrics/web-vitals/lib/onHidden.js","webpack://spartner/./node_modules/@sentry-internal/browser-utils/build/esm/types.js","webpack://spartner/./node_modules/@sentry-internal/replay/build/npm/esm/index.js","webpack://spartner/./node_modules/scroll-into-view-if-needed/dist/index.js"],"sourcesContent":["/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nconst DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);\n\nexport { DEBUG_BUILD };\n//# sourceMappingURL=debug-build.js.map\n","import { isNativeFunction, logger } from '@sentry/core';\nimport { DEBUG_BUILD } from './debug-build.js';\nimport { WINDOW } from './types.js';\n\n/**\n * We generally want to use window.fetch / window.setTimeout.\n * However, in some cases this may be wrapped (e.g. by Zone.js for Angular),\n * so we try to get an unpatched version of this from a sandboxed iframe.\n */\n\nconst cachedImplementations = {};\n\n/**\n * Get the native implementation of a browser function.\n *\n * This can be used to ensure we get an unwrapped version of a function, in cases where a wrapped function can lead to problems.\n *\n * The following methods can be retrieved:\n * - `setTimeout`: This can be wrapped by e.g. Angular, causing change detection to be triggered.\n * - `fetch`: This can be wrapped by e.g. ad-blockers, causing an infinite loop when a request is blocked.\n */\nfunction getNativeImplementation(\n  name,\n) {\n  const cached = cachedImplementations[name];\n  if (cached) {\n    return cached;\n  }\n\n  let impl = WINDOW[name] ;\n\n  // Fast path to avoid DOM I/O\n  if (isNativeFunction(impl)) {\n    return (cachedImplementations[name] = impl.bind(WINDOW) );\n  }\n\n  const document = WINDOW.document;\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[name]) {\n        impl = contentWindow[name] ;\n      }\n      document.head.removeChild(sandbox);\n    } catch (e) {\n      // Could not create sandbox iframe, just use window.xxx\n      DEBUG_BUILD && logger.warn(`Could not create sandbox iframe for ${name} check, bailing to window.${name}: `, e);\n    }\n  }\n\n  // Sanity check: This _should_ not happen, but if it does, we just skip caching...\n  // This can happen e.g. in tests where fetch may not be available in the env, or similar.\n  if (!impl) {\n    return impl;\n  }\n\n  return (cachedImplementations[name] = impl.bind(WINDOW) );\n}\n\n/** Clear a cached implementation. */\nfunction clearCachedImplementation(name) {\n  cachedImplementations[name] = undefined;\n}\n\n/**\n * A special usecase for incorrectly wrapped Fetch APIs in conjunction with ad-blockers.\n * Whenever someone wraps the Fetch API and returns the wrong promise chain,\n * this chain becomes orphaned and there is no possible way to capture it's rejections\n * other than allowing it bubble up to this very handler. eg.\n *\n * const f = window.fetch;\n * window.fetch = function () {\n *   const p = f.apply(this, arguments);\n *\n *   p.then(function() {\n *     console.log('hi.');\n *   });\n *\n *   return p;\n * }\n *\n * `p.then(function () { ... })` is producing a completely separate promise chain,\n * however, what's returned is `p` - the result of original `fetch` call.\n *\n * This mean, that whenever we use the Fetch API to send our own requests, _and_\n * some ad-blocker blocks it, this orphaned chain will _always_ reject,\n * effectively causing another event to be captured.\n * This makes a whole process become an infinite loop, which we need to somehow\n * deal with, and break it in one way or another.\n *\n * To deal with this issue, we are making sure that we _always_ use the real\n * browser Fetch API, instead of relying on what `window.fetch` exposes.\n * The only downside to this would be missing our own requests as breadcrumbs,\n * but because we are already not doing this, it should be just fine.\n *\n * Possible failed fetch error messages per-browser:\n *\n * Chrome:  Failed to fetch\n * Edge:    Failed to Fetch\n * Firefox: NetworkError when attempting to fetch resource\n * Safari:  resource blocked by content blocker\n */\nfunction fetch(...rest) {\n  return getNativeImplementation('fetch')(...rest);\n}\n\n/**\n * Get an unwrapped `setTimeout` method.\n * This ensures that even if e.g. Angular wraps `setTimeout`, we get the native implementation,\n * avoiding triggering change detection.\n */\nfunction setTimeout(...rest) {\n  return getNativeImplementation('setTimeout')(...rest);\n}\n\nexport { clearCachedImplementation, fetch, getNativeImplementation, setTimeout };\n//# sourceMappingURL=getNativeImplementation.js.map\n","import { addHandler, maybeInstrument, triggerHandlers, fill, addNonEnumerableProperty, uuid4 } from '@sentry/core';\nimport { WINDOW } from '../types.js';\n\nconst DEBOUNCE_DURATION = 1000;\n\nlet debounceTimerID;\nlet lastCapturedEventType;\nlet lastCapturedEventTargetId;\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 */\nfunction addClickKeypressInstrumentationHandler(handler) {\n  const type = 'dom';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentDOM);\n}\n\n/** Exported for tests only. */\nfunction instrumentDOM() {\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) => {\n    const globalObject = WINDOW ;\n    const targetObj = globalObject[target];\n    const proto = targetObj && targetObj.prototype;\n\n    // eslint-disable-next-line no-prototype-builtins\n    if (!proto || !proto.hasOwnProperty || !proto.hasOwnProperty('addEventListener')) {\n      return;\n    }\n\n    fill(proto, 'addEventListener', function (originalAddEventListener) {\n      return function ( type, listener, options) {\n        if (type === 'click' || type == 'keypress') {\n          try {\n            const handlers = (this.__sentry_instrumentation_handlers__ =\n              this.__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 `addEventListeners` calls with no proper `this` context.\n          }\n        }\n\n        return originalAddEventListener.call(this, type, listener, options);\n      };\n    });\n\n    fill(\n      proto,\n      'removeEventListener',\n      function (originalRemoveEventListener) {\n        return function ( type, listener, options) {\n          if (type === 'click' || type == 'keypress') {\n            try {\n              const handlers = this.__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 this.__sentry_instrumentation_handlers__;\n                }\n              }\n            } catch (e) {\n              // Accessing dom properties is always fragile.\n              // Also allows us to skip `addEventListeners` 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) {\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 )._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, target) {\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,\n  globalListener = false,\n) {\n  return (event) => {\n    // It's possible this handler might trigger multiple times for the same\n    // event (e.g. event propagation through node ancestors).\n    // Ignore if we've already captured that event.\n    if (!event || 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 = { 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) {\n  try {\n    return event.target ;\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\nexport { addClickKeypressInstrumentationHandler, instrumentDOM };\n//# sourceMappingURL=dom.js.map\n","import { addHandler, maybeInstrument, supportsHistory, triggerHandlers, fill } from '@sentry/core';\nimport { WINDOW } from '../types.js';\n\nlet lastHref;\n\n/**\n * Add an instrumentation handler for when a fetch request happens.\n * The handler function is called once when the request starts and once when it ends,\n * which can be identified by checking if it has an `endTimestamp`.\n *\n * Use at your own risk, this might break without changelog notice, only used internally.\n * @hidden\n */\nfunction addHistoryInstrumentationHandler(handler) {\n  const type = 'history';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentHistory);\n}\n\nfunction instrumentHistory() {\n  if (!supportsHistory()) {\n    return;\n  }\n\n  const oldOnPopState = WINDOW.onpopstate;\n  WINDOW.onpopstate = function ( ...args) {\n    const to = WINDOW.location.href;\n    // keep track of the current URL state, as we always receive only the updated state\n    const from = lastHref;\n    lastHref = to;\n    const handlerData = { 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) {\n    return function ( ...args) {\n      const url = args.length > 2 ? args[2] : undefined;\n      if (url) {\n        // coerce to string (this is what pushState does)\n        const from = lastHref;\n        const to = String(url);\n        // keep track of the current URL state, as we always receive only the updated state\n        lastHref = to;\n        const handlerData = { 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\nexport { addHistoryInstrumentationHandler };\n//# sourceMappingURL=history.js.map\n","import { addHandler, maybeInstrument, timestampInSeconds, isString, triggerHandlers } from '@sentry/core';\nimport { WINDOW } from '../types.js';\n\nconst 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 */\nfunction addXhrInstrumentationHandler(handler) {\n  const type = 'xhr';\n  addHandler(type, handler);\n  maybeInstrument(type, instrumentXHR);\n}\n\n/** Exported only for tests. */\nfunction instrumentXHR() {\n  if (!(WINDOW ).XMLHttpRequest) {\n    return;\n  }\n\n  const xhrproto = XMLHttpRequest.prototype;\n\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  xhrproto.open = new Proxy(xhrproto.open, {\n    apply(originalOpen, xhrOpenThisArg, xhrOpenArgArray) {\n      // NOTE: If you are a Sentry user, and you are seeing this stack frame,\n      //       it means the error, that was caused by your XHR call did not\n      //       have a stack trace. If you are using HttpClient integration,\n      //       this is the expected behavior, as we are using this virtual error to capture\n      //       the location of your XHR call, and group your HttpClient events accordingly.\n      const virtualError = new Error();\n\n      const startTimestamp = timestampInSeconds() * 1000;\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(xhrOpenArgArray[0]) ? xhrOpenArgArray[0].toUpperCase() : undefined;\n      const url = parseUrl(xhrOpenArgArray[1]);\n\n      if (!method || !url) {\n        return originalOpen.apply(xhrOpenThisArg, xhrOpenArgArray);\n      }\n\n      xhrOpenThisArg[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        xhrOpenThisArg.__sentry_own_request__ = true;\n      }\n\n      const onreadystatechangeHandler = () => {\n        // For whatever reason, this is not the same instance here as from the outer method\n        const xhrInfo = xhrOpenThisArg[SENTRY_XHR_DATA_KEY];\n\n        if (!xhrInfo) {\n          return;\n        }\n\n        if (xhrOpenThisArg.readyState === 4) {\n          try {\n            // touching statusCode in some platforms throws\n            // an exception\n            xhrInfo.status_code = xhrOpenThisArg.status;\n          } catch (e) {\n            /* do nothing */\n          }\n\n          const handlerData = {\n            endTimestamp: timestampInSeconds() * 1000,\n            startTimestamp,\n            xhr: xhrOpenThisArg,\n            virtualError,\n          };\n          triggerHandlers('xhr', handlerData);\n        }\n      };\n\n      if ('onreadystatechange' in xhrOpenThisArg && typeof xhrOpenThisArg.onreadystatechange === 'function') {\n        xhrOpenThisArg.onreadystatechange = new Proxy(xhrOpenThisArg.onreadystatechange, {\n          apply(originalOnreadystatechange, onreadystatechangeThisArg, onreadystatechangeArgArray) {\n            onreadystatechangeHandler();\n            return originalOnreadystatechange.apply(onreadystatechangeThisArg, onreadystatechangeArgArray);\n          },\n        });\n      } else {\n        xhrOpenThisArg.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      xhrOpenThisArg.setRequestHeader = new Proxy(xhrOpenThisArg.setRequestHeader, {\n        apply(\n          originalSetRequestHeader,\n          setRequestHeaderThisArg,\n          setRequestHeaderArgArray,\n        ) {\n          const [header, value] = setRequestHeaderArgArray;\n\n          const xhrInfo = setRequestHeaderThisArg[SENTRY_XHR_DATA_KEY];\n\n          if (xhrInfo && isString(header) && isString(value)) {\n            xhrInfo.request_headers[header.toLowerCase()] = value;\n          }\n\n          return originalSetRequestHeader.apply(setRequestHeaderThisArg, setRequestHeaderArgArray);\n        },\n      });\n\n      return originalOpen.apply(xhrOpenThisArg, xhrOpenArgArray);\n    },\n  });\n\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  xhrproto.send = new Proxy(xhrproto.send, {\n    apply(originalSend, sendThisArg, sendArgArray) {\n      const sentryXhrData = sendThisArg[SENTRY_XHR_DATA_KEY];\n\n      if (!sentryXhrData) {\n        return originalSend.apply(sendThisArg, sendArgArray);\n      }\n\n      if (sendArgArray[0] !== undefined) {\n        sentryXhrData.body = sendArgArray[0];\n      }\n\n      const handlerData = {\n        startTimestamp: timestampInSeconds() * 1000,\n        xhr: sendThisArg,\n      };\n      triggerHandlers('xhr', handlerData);\n\n      return originalSend.apply(sendThisArg, sendArgArray);\n    },\n  });\n}\n\nfunction parseUrl(url) {\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 ).toString();\n  } catch (e2) {} // eslint-disable-line no-empty\n\n  return undefined;\n}\n\nexport { SENTRY_XHR_DATA_KEY, addXhrInstrumentationHandler, instrumentXHR };\n//# sourceMappingURL=xhr.js.map\n","import { browserPerformanceTimeOrigin, getActiveSpan, spanToJSON, setMeasurement, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, parseUrl, htmlTreeAsString, getComponentName } from '@sentry/core';\nimport { WINDOW } from '../types.js';\nimport { trackClsAsStandaloneSpan } from './cls.js';\nimport { addPerformanceInstrumentationHandler, addClsInstrumentationHandler, addLcpInstrumentationHandler, addFidInstrumentationHandler, addTtfbInstrumentationHandler } from './instrument.js';\nimport { getBrowserPerformanceAPI, msToSec, startAndEndSpan, isMeasurementValue } from './utils.js';\nimport { getActivationStart } from './web-vitals/lib/getActivationStart.js';\nimport { getNavigationEntry } from './web-vitals/lib/getNavigationEntry.js';\nimport { getVisibilityWatcher } from './web-vitals/lib/getVisibilityWatcher.js';\n\nconst MAX_INT_AS_BYTES = 2147483647;\n\nlet _performanceCursor = 0;\n\nlet _measurements = {};\nlet _lcpEntry;\nlet _clsEntry;\n\n/**\n * Start tracking web vitals.\n * The callback returned by this function can be used to stop tracking & ensure all measurements are final & captured.\n *\n * @returns A function that forces web vitals collection\n */\nfunction startTrackingWebVitals({ recordClsStandaloneSpans }) {\n  const performance = getBrowserPerformanceAPI();\n  if (performance && browserPerformanceTimeOrigin) {\n    // @ts-expect-error we want to make sure all of these are available, even if TS is sure they are\n    if (performance.mark) {\n      WINDOW.performance.mark('sentry-tracing-init');\n    }\n    const fidCleanupCallback = _trackFID();\n    const lcpCleanupCallback = _trackLCP();\n    const ttfbCleanupCallback = _trackTtfb();\n    const clsCleanupCallback = recordClsStandaloneSpans ? trackClsAsStandaloneSpan() : _trackCLS();\n\n    return () => {\n      fidCleanupCallback();\n      lcpCleanupCallback();\n      ttfbCleanupCallback();\n      clsCleanupCallback && clsCleanupCallback();\n    };\n  }\n\n  return () => undefined;\n}\n\n/**\n * Start tracking long tasks.\n */\nfunction startTrackingLongTasks() {\n  addPerformanceInstrumentationHandler('longtask', ({ entries }) => {\n    const parent = getActiveSpan();\n    if (!parent) {\n      return;\n    }\n\n    const { op: parentOp, start_timestamp: parentStartTimestamp } = spanToJSON(parent);\n\n    for (const entry of entries) {\n      const startTime = msToSec((browserPerformanceTimeOrigin ) + entry.startTime);\n      const duration = msToSec(entry.duration);\n\n      if (parentOp === 'navigation' && parentStartTimestamp && startTime < parentStartTimestamp) {\n        // Skip adding a span if the long task started before the navigation started.\n        // `startAndEndSpan` will otherwise adjust the parent's start time to the span's start\n        // time, potentially skewing the duration of the actual navigation as reported via our\n        // routing instrumentations\n        continue;\n      }\n\n      startAndEndSpan(parent, startTime, startTime + duration, {\n        name: 'Main UI thread blocked',\n        op: 'ui.long-task',\n        attributes: {\n          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n        },\n      });\n    }\n  });\n}\n\n/**\n * Start tracking long animation frames.\n */\nfunction startTrackingLongAnimationFrames() {\n  // NOTE: the current web-vitals version (3.5.2) does not support long-animation-frame, so\n  // we directly observe `long-animation-frame` events instead of through the web-vitals\n  // `observe` helper function.\n  const observer = new PerformanceObserver(list => {\n    const parent = getActiveSpan();\n    if (!parent) {\n      return;\n    }\n    for (const entry of list.getEntries() ) {\n      if (!entry.scripts[0]) {\n        continue;\n      }\n\n      const startTime = msToSec((browserPerformanceTimeOrigin ) + entry.startTime);\n\n      const { start_timestamp: parentStartTimestamp, op: parentOp } = spanToJSON(parent);\n\n      if (parentOp === 'navigation' && parentStartTimestamp && startTime < parentStartTimestamp) {\n        // Skip adding the span if the long animation frame started before the navigation started.\n        // `startAndEndSpan` will otherwise adjust the parent's start time to the span's start\n        // time, potentially skewing the duration of the actual navigation as reported via our\n        // routing instrumentations\n        continue;\n      }\n\n      const duration = msToSec(entry.duration);\n\n      const attributes = {\n        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n      };\n\n      const initialScript = entry.scripts[0];\n      const { invoker, invokerType, sourceURL, sourceFunctionName, sourceCharPosition } = initialScript;\n      attributes['browser.script.invoker'] = invoker;\n      attributes['browser.script.invoker_type'] = invokerType;\n      if (sourceURL) {\n        attributes['code.filepath'] = sourceURL;\n      }\n      if (sourceFunctionName) {\n        attributes['code.function'] = sourceFunctionName;\n      }\n      if (sourceCharPosition !== -1) {\n        attributes['browser.script.source_char_position'] = sourceCharPosition;\n      }\n\n      startAndEndSpan(parent, startTime, startTime + duration, {\n        name: 'Main UI thread blocked',\n        op: 'ui.long-animation-frame',\n        attributes,\n      });\n    }\n  });\n\n  observer.observe({ type: 'long-animation-frame', buffered: true });\n}\n\n/**\n * Start tracking interaction events.\n */\nfunction startTrackingInteractions() {\n  addPerformanceInstrumentationHandler('event', ({ entries }) => {\n    const parent = getActiveSpan();\n    if (!parent) {\n      return;\n    }\n    for (const entry of entries) {\n      if (entry.name === 'click') {\n        const startTime = msToSec((browserPerformanceTimeOrigin ) + entry.startTime);\n        const duration = msToSec(entry.duration);\n\n        const spanOptions = {\n          name: htmlTreeAsString(entry.target),\n          op: `ui.interaction.${entry.name}`,\n          startTime: startTime,\n          attributes: {\n            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n          },\n        };\n\n        const componentName = getComponentName(entry.target);\n        if (componentName) {\n          spanOptions.attributes['ui.component_name'] = componentName;\n        }\n\n        startAndEndSpan(parent, startTime, startTime + duration, spanOptions);\n      }\n    }\n  });\n}\n\n/**\n * Starts tracking the Cumulative Layout Shift on the current page and collects the value and last entry\n * to the `_measurements` object which ultimately is applied to the pageload span's measurements.\n */\nfunction _trackCLS() {\n  return addClsInstrumentationHandler(({ metric }) => {\n    const entry = metric.entries[metric.entries.length - 1] ;\n    if (!entry) {\n      return;\n    }\n    _measurements['cls'] = { value: metric.value, unit: '' };\n    _clsEntry = entry;\n  }, true);\n}\n\n/** Starts tracking the Largest Contentful Paint on the current page. */\nfunction _trackLCP() {\n  return addLcpInstrumentationHandler(({ metric }) => {\n    const entry = metric.entries[metric.entries.length - 1];\n    if (!entry) {\n      return;\n    }\n\n    _measurements['lcp'] = { value: metric.value, unit: 'millisecond' };\n    _lcpEntry = entry ;\n  }, true);\n}\n\n/** Starts tracking the First Input Delay on the current page. */\nfunction _trackFID() {\n  return addFidInstrumentationHandler(({ metric }) => {\n    const entry = metric.entries[metric.entries.length - 1];\n    if (!entry) {\n      return;\n    }\n\n    const timeOrigin = msToSec(browserPerformanceTimeOrigin );\n    const startTime = msToSec(entry.startTime);\n    _measurements['fid'] = { value: metric.value, unit: 'millisecond' };\n    _measurements['mark.fid'] = { value: timeOrigin + startTime, unit: 'second' };\n  });\n}\n\nfunction _trackTtfb() {\n  return addTtfbInstrumentationHandler(({ metric }) => {\n    const entry = metric.entries[metric.entries.length - 1];\n    if (!entry) {\n      return;\n    }\n\n    _measurements['ttfb'] = { value: metric.value, unit: 'millisecond' };\n  });\n}\n\n/** Add performance related spans to a transaction */\nfunction addPerformanceEntries(span, options) {\n  const performance = getBrowserPerformanceAPI();\n  if (!performance || !performance.getEntries || !browserPerformanceTimeOrigin) {\n    // Gatekeeper if performance API not available\n    return;\n  }\n\n  const timeOrigin = msToSec(browserPerformanceTimeOrigin);\n\n  const performanceEntries = performance.getEntries();\n\n  const { op, start_timestamp: transactionStartTime } = spanToJSON(span);\n\n  performanceEntries.slice(_performanceCursor).forEach(entry => {\n    const startTime = msToSec(entry.startTime);\n    const duration = msToSec(\n      // Inexplicably, Chrome sometimes emits a negative duration. We need to work around this.\n      // There is a SO post attempting to explain this, but it leaves one with open questions: https://stackoverflow.com/questions/23191918/peformance-getentries-and-negative-duration-display\n      // The way we clamp the value is probably not accurate, since we have observed this happen for things that may take a while to load, like for example the replay worker.\n      // TODO: Investigate why this happens and how to properly mitigate. For now, this is a workaround to prevent transactions being dropped due to negative duration spans.\n      Math.max(0, entry.duration),\n    );\n\n    if (op === 'navigation' && transactionStartTime && timeOrigin + startTime < transactionStartTime) {\n      return;\n    }\n\n    switch (entry.entryType) {\n      case 'navigation': {\n        _addNavigationSpans(span, entry , timeOrigin);\n        break;\n      }\n      case 'mark':\n      case 'paint':\n      case 'measure': {\n        _addMeasureSpans(span, entry, startTime, duration, timeOrigin);\n\n        // capture web vitals\n        const firstHidden = getVisibilityWatcher();\n        // Only report if the page wasn't hidden prior to the web vital.\n        const shouldRecord = entry.startTime < firstHidden.firstHiddenTime;\n\n        if (entry.name === 'first-paint' && shouldRecord) {\n          _measurements['fp'] = { value: entry.startTime, unit: 'millisecond' };\n        }\n        if (entry.name === 'first-contentful-paint' && shouldRecord) {\n          _measurements['fcp'] = { value: entry.startTime, unit: 'millisecond' };\n        }\n        break;\n      }\n      case 'resource': {\n        _addResourceSpans(span, entry , entry.name, startTime, duration, timeOrigin);\n        break;\n      }\n      // Ignore other entry types.\n    }\n  });\n\n  _performanceCursor = Math.max(performanceEntries.length - 1, 0);\n\n  _trackNavigator(span);\n\n  // Measurements are only available for pageload transactions\n  if (op === 'pageload') {\n    _addTtfbRequestTimeToMeasurements(_measurements);\n\n    const fidMark = _measurements['mark.fid'];\n    if (fidMark && _measurements['fid']) {\n      // create span for FID\n      startAndEndSpan(span, fidMark.value, fidMark.value + msToSec(_measurements['fid'].value), {\n        name: 'first input delay',\n        op: 'ui.action',\n        attributes: {\n          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n        },\n      });\n\n      // Delete mark.fid as we don't want it to be part of final payload\n      delete _measurements['mark.fid'];\n    }\n\n    // If FCP is not recorded we should not record the cls value\n    // according to the new definition of CLS.\n    // TODO: Check if the first condition is still necessary: `onCLS` already only fires once `onFCP` was called.\n    if (!('fcp' in _measurements) || !options.recordClsOnPageloadSpan) {\n      delete _measurements.cls;\n    }\n\n    Object.entries(_measurements).forEach(([measurementName, measurement]) => {\n      setMeasurement(measurementName, measurement.value, measurement.unit);\n    });\n\n    // Set timeOrigin which denotes the timestamp which to base the LCP/FCP/FP/TTFB measurements on\n    span.setAttribute('performance.timeOrigin', timeOrigin);\n\n    // In prerendering scenarios, where a page might be prefetched and pre-rendered before the user clicks the link,\n    // the navigation starts earlier than when the user clicks it. Web Vitals should always be based on the\n    // user-perceived time, so they are not reported from the actual start of the navigation, but rather from the\n    // time where the user actively started the navigation, for example by clicking a link.\n    // This is user action is called \"activation\" and the time between navigation and activation is stored in\n    // the `activationStart` attribute of the \"navigation\" PerformanceEntry.\n    span.setAttribute('performance.activationStart', getActivationStart());\n\n    _setWebVitalAttributes(span);\n  }\n\n  _lcpEntry = undefined;\n  _clsEntry = undefined;\n  _measurements = {};\n}\n\n/**\n * Create measure related spans.\n * Exported only for tests.\n */\nfunction _addMeasureSpans(\n  span,\n  entry,\n  startTime,\n  duration,\n  timeOrigin,\n) {\n  const navEntry = getNavigationEntry(false);\n  const requestTime = msToSec(navEntry ? navEntry.requestStart : 0);\n  // Because performance.measure accepts arbitrary timestamps it can produce\n  // spans that happen before the browser even makes a request for the page.\n  //\n  // An example of this is the automatically generated Next.js-before-hydration\n  // spans created by the Next.js framework.\n  //\n  // To prevent this we will pin the start timestamp to the request start time\n  // This does make duration inaccurate, so if this does happen, we will add\n  // an attribute to the span\n  const measureStartTimestamp = timeOrigin + Math.max(startTime, requestTime);\n  const startTimeStamp = timeOrigin + startTime;\n  const measureEndTimestamp = startTimeStamp + duration;\n\n  const attributes = {\n    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.resource.browser.metrics',\n  };\n\n  if (measureStartTimestamp !== startTimeStamp) {\n    attributes['sentry.browser.measure_happened_before_request'] = true;\n    attributes['sentry.browser.measure_start_time'] = measureStartTimestamp;\n  }\n\n  startAndEndSpan(span, measureStartTimestamp, measureEndTimestamp, {\n    name: entry.name ,\n    op: entry.entryType ,\n    attributes,\n  });\n\n  return measureStartTimestamp;\n}\n\n/** Instrument navigation entries */\nfunction _addNavigationSpans(span, entry, timeOrigin) {\n  (['unloadEvent', 'redirect', 'domContentLoadedEvent', 'loadEvent', 'connect'] ).forEach(event => {\n    _addPerformanceNavigationTiming(span, entry, event, timeOrigin);\n  });\n  _addPerformanceNavigationTiming(span, entry, 'secureConnection', timeOrigin, 'TLS/SSL');\n  _addPerformanceNavigationTiming(span, entry, 'fetch', timeOrigin, 'cache');\n  _addPerformanceNavigationTiming(span, entry, 'domainLookup', timeOrigin, 'DNS');\n\n  _addRequest(span, entry, timeOrigin);\n}\n\n/** Create performance navigation related spans */\nfunction _addPerformanceNavigationTiming(\n  span,\n  entry,\n  event,\n  timeOrigin,\n  name = event,\n) {\n  const eventEnd = _getEndPropertyNameForNavigationTiming(event) ;\n  const end = entry[eventEnd];\n  const start = entry[`${event}Start`];\n  if (!start || !end) {\n    return;\n  }\n  startAndEndSpan(span, timeOrigin + msToSec(start), timeOrigin + msToSec(end), {\n    op: `browser.${name}`,\n    name: entry.name,\n    attributes: {\n      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n    },\n  });\n}\n\nfunction _getEndPropertyNameForNavigationTiming(event) {\n  if (event === 'secureConnection') {\n    return 'connectEnd';\n  }\n  if (event === 'fetch') {\n    return 'domainLookupStart';\n  }\n  return `${event}End`;\n}\n\n/** Create request and response related spans */\nfunction _addRequest(span, entry, timeOrigin) {\n  const requestStartTimestamp = timeOrigin + msToSec(entry.requestStart );\n  const responseEndTimestamp = timeOrigin + msToSec(entry.responseEnd );\n  const responseStartTimestamp = timeOrigin + msToSec(entry.responseStart );\n  if (entry.responseEnd) {\n    // It is possible that we are collecting these metrics when the page hasn't finished loading yet, for example when the HTML slowly streams in.\n    // In this case, ie. when the document request hasn't finished yet, `entry.responseEnd` will be 0.\n    // In order not to produce faulty spans, where the end timestamp is before the start timestamp, we will only collect\n    // these spans when the responseEnd value is available. The backend (Relay) would drop the entire span if it contained faulty spans.\n    startAndEndSpan(span, requestStartTimestamp, responseEndTimestamp, {\n      op: 'browser.request',\n      name: entry.name,\n      attributes: {\n        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n      },\n    });\n\n    startAndEndSpan(span, responseStartTimestamp, responseEndTimestamp, {\n      op: 'browser.response',\n      name: entry.name,\n      attributes: {\n        [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.ui.browser.metrics',\n      },\n    });\n  }\n}\n\n/**\n * Create resource-related spans.\n * Exported only for tests.\n */\nfunction _addResourceSpans(\n  span,\n  entry,\n  resourceUrl,\n  startTime,\n  duration,\n  timeOrigin,\n) {\n  // we already instrument based on fetch and xhr, so we don't need to\n  // duplicate spans here.\n  if (entry.initiatorType === 'xmlhttprequest' || entry.initiatorType === 'fetch') {\n    return;\n  }\n\n  const parsedUrl = parseUrl(resourceUrl);\n\n  const attributes = {\n    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.resource.browser.metrics',\n  };\n  setResourceEntrySizeData(attributes, entry, 'transferSize', 'http.response_transfer_size');\n  setResourceEntrySizeData(attributes, entry, 'encodedBodySize', 'http.response_content_length');\n  setResourceEntrySizeData(attributes, entry, 'decodedBodySize', 'http.decoded_response_content_length');\n\n  // `deliveryType` is experimental and does not exist everywhere\n  const deliveryType = (entry ).deliveryType;\n  if (deliveryType != null) {\n    attributes['http.response_delivery_type'] = deliveryType;\n  }\n\n  // Types do not reflect this property yet\n  const renderBlockingStatus = (entry )\n    .renderBlockingStatus;\n  if (renderBlockingStatus) {\n    attributes['resource.render_blocking_status'] = renderBlockingStatus;\n  }\n\n  if (parsedUrl.protocol) {\n    attributes['url.scheme'] = parsedUrl.protocol.split(':').pop(); // the protocol returned by parseUrl includes a :, but OTEL spec does not, so we remove it.\n  }\n\n  if (parsedUrl.host) {\n    attributes['server.address'] = parsedUrl.host;\n  }\n\n  attributes['url.same_origin'] = resourceUrl.includes(WINDOW.location.origin);\n\n  const startTimestamp = timeOrigin + startTime;\n  const endTimestamp = startTimestamp + duration;\n\n  startAndEndSpan(span, startTimestamp, endTimestamp, {\n    name: resourceUrl.replace(WINDOW.location.origin, ''),\n    op: entry.initiatorType ? `resource.${entry.initiatorType}` : 'resource.other',\n    attributes,\n  });\n}\n\n/**\n * Capture the information of the user agent.\n */\nfunction _trackNavigator(span) {\n  const navigator = WINDOW.navigator ;\n  if (!navigator) {\n    return;\n  }\n\n  // track network connectivity\n  const connection = navigator.connection;\n  if (connection) {\n    if (connection.effectiveType) {\n      span.setAttribute('effectiveConnectionType', connection.effectiveType);\n    }\n\n    if (connection.type) {\n      span.setAttribute('connectionType', connection.type);\n    }\n\n    if (isMeasurementValue(connection.rtt)) {\n      _measurements['connection.rtt'] = { value: connection.rtt, unit: 'millisecond' };\n    }\n  }\n\n  if (isMeasurementValue(navigator.deviceMemory)) {\n    span.setAttribute('deviceMemory', `${navigator.deviceMemory} GB`);\n  }\n\n  if (isMeasurementValue(navigator.hardwareConcurrency)) {\n    span.setAttribute('hardwareConcurrency', String(navigator.hardwareConcurrency));\n  }\n}\n\n/** Add LCP / CLS data to span to allow debugging */\nfunction _setWebVitalAttributes(span) {\n  if (_lcpEntry) {\n    // Capture Properties of the LCP element that contributes to the LCP.\n\n    if (_lcpEntry.element) {\n      span.setAttribute('lcp.element', htmlTreeAsString(_lcpEntry.element));\n    }\n\n    if (_lcpEntry.id) {\n      span.setAttribute('lcp.id', _lcpEntry.id);\n    }\n\n    if (_lcpEntry.url) {\n      // Trim URL to the first 200 characters.\n      span.setAttribute('lcp.url', _lcpEntry.url.trim().slice(0, 200));\n    }\n\n    if (_lcpEntry.loadTime != null) {\n      // loadTime is the time of LCP that's related to receiving the LCP element response..\n      span.setAttribute('lcp.loadTime', _lcpEntry.loadTime);\n    }\n\n    if (_lcpEntry.renderTime != null) {\n      // renderTime is loadTime + rendering time\n      // it's 0 if the LCP element is loaded from a 3rd party origin that doesn't send the\n      // `Timing-Allow-Origin` header.\n      span.setAttribute('lcp.renderTime', _lcpEntry.renderTime);\n    }\n\n    span.setAttribute('lcp.size', _lcpEntry.size);\n  }\n\n  // See: https://developer.mozilla.org/en-US/docs/Web/API/LayoutShift\n  if (_clsEntry && _clsEntry.sources) {\n    _clsEntry.sources.forEach((source, index) =>\n      span.setAttribute(`cls.source.${index + 1}`, htmlTreeAsString(source.node)),\n    );\n  }\n}\n\nfunction setResourceEntrySizeData(\n  attributes,\n  entry,\n  key,\n  dataKey,\n) {\n  const entryVal = entry[key];\n  if (entryVal != null && entryVal < MAX_INT_AS_BYTES) {\n    attributes[dataKey] = entryVal;\n  }\n}\n\n/**\n * Add ttfb request time information to measurements.\n *\n * ttfb information is added via vendored web vitals library.\n */\nfunction _addTtfbRequestTimeToMeasurements(_measurements) {\n  const navEntry = getNavigationEntry(false);\n  if (!navEntry) {\n    return;\n  }\n\n  const { responseStart, requestStart } = navEntry;\n\n  if (requestStart <= responseStart) {\n    _measurements['ttfb.requestTime'] = {\n      value: responseStart - requestStart,\n      unit: 'millisecond',\n    };\n  }\n}\n\nexport { _addMeasureSpans, _addResourceSpans, addPerformanceEntries, startTrackingInteractions, startTrackingLongAnimationFrames, startTrackingLongTasks, startTrackingWebVitals };\n//# sourceMappingURL=browserMetrics.js.map\n","import { getClient, getActiveSpan, getRootSpan, spanToJSON, logger, browserPerformanceTimeOrigin, getCurrentScope, htmlTreeAsString, dropUndefinedKeys, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME, SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT, SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { addClsInstrumentationHandler } from './instrument.js';\nimport { msToSec, startStandaloneWebVitalSpan } from './utils.js';\nimport { onHidden } from './web-vitals/lib/onHidden.js';\n\n/**\n * Starts tracking the Cumulative Layout Shift on the current page and collects the value once\n *\n * - the page visibility is hidden\n * - a navigation span is started (to stop CLS measurement for SPA soft navigations)\n *\n * Once either of these events triggers, the CLS value is sent as a standalone span and we stop\n * measuring CLS.\n */\nfunction trackClsAsStandaloneSpan() {\n  let standaloneCLsValue = 0;\n  let standaloneClsEntry;\n  let pageloadSpanId;\n\n  if (!supportsLayoutShift()) {\n    return;\n  }\n\n  let sentSpan = false;\n  function _collectClsOnce() {\n    if (sentSpan) {\n      return;\n    }\n    sentSpan = true;\n    if (pageloadSpanId) {\n      sendStandaloneClsSpan(standaloneCLsValue, standaloneClsEntry, pageloadSpanId);\n    }\n    cleanupClsHandler();\n  }\n\n  const cleanupClsHandler = addClsInstrumentationHandler(({ metric }) => {\n    const entry = metric.entries[metric.entries.length - 1] ;\n    if (!entry) {\n      return;\n    }\n    standaloneCLsValue = metric.value;\n    standaloneClsEntry = entry;\n  }, true);\n\n  // use pagehide event from web-vitals\n  onHidden(() => {\n    _collectClsOnce();\n  });\n\n  // Since the call chain of this function is synchronous and evaluates before the SDK client is created,\n  // we need to wait with subscribing to a client hook until the client is created. Therefore, we defer\n  // to the next tick after the SDK setup.\n  setTimeout(() => {\n    const client = getClient();\n\n    if (!client) {\n      return;\n    }\n\n    const unsubscribeStartNavigation = client.on('startNavigationSpan', () => {\n      _collectClsOnce();\n      unsubscribeStartNavigation && unsubscribeStartNavigation();\n    });\n\n    const activeSpan = getActiveSpan();\n    const rootSpan = activeSpan && getRootSpan(activeSpan);\n    const spanJSON = rootSpan && spanToJSON(rootSpan);\n    if (spanJSON && spanJSON.op === 'pageload') {\n      pageloadSpanId = rootSpan.spanContext().spanId;\n    }\n  }, 0);\n}\n\nfunction sendStandaloneClsSpan(clsValue, entry, pageloadSpanId) {\n  DEBUG_BUILD && logger.log(`Sending CLS span (${clsValue})`);\n\n  const startTime = msToSec((browserPerformanceTimeOrigin || 0) + ((entry && entry.startTime) || 0));\n  const routeName = getCurrentScope().getScopeData().transactionName;\n\n  const name = entry ? htmlTreeAsString(entry.sources[0] && entry.sources[0].node) : 'Layout shift';\n\n  const attributes = dropUndefinedKeys({\n    [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.browser.cls',\n    [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'ui.webvital.cls',\n    [SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME]: (entry && entry.duration) || 0,\n    // attach the pageload span id to the CLS span so that we can link them in the UI\n    'sentry.pageload.span_id': pageloadSpanId,\n  });\n\n  const span = startStandaloneWebVitalSpan({\n    name,\n    transaction: routeName,\n    attributes,\n    startTime,\n  });\n\n  if (span) {\n    span.addEvent('cls', {\n      [SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT]: '',\n      [SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE]: clsValue,\n    });\n\n    // LayoutShift performance entries always have a duration of 0, so we don't need to add `entry.duration` here\n    // see: https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntry/duration\n    span.end(startTime);\n  }\n}\n\nfunction supportsLayoutShift() {\n  try {\n    return PerformanceObserver.supportedEntryTypes.includes('layout-shift');\n  } catch (e) {\n    return false;\n  }\n}\n\nexport { trackClsAsStandaloneSpan };\n//# sourceMappingURL=cls.js.map\n","import { browserPerformanceTimeOrigin, getActiveSpan, getRootSpan, spanToJSON, getCurrentScope, htmlTreeAsString, dropUndefinedKeys, SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN, SEMANTIC_ATTRIBUTE_SENTRY_OP, SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME, SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT, SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE } from '@sentry/core';\nimport { addInpInstrumentationHandler, addPerformanceInstrumentationHandler, isPerformanceEventTiming } from './instrument.js';\nimport { getBrowserPerformanceAPI, msToSec, startStandaloneWebVitalSpan } from './utils.js';\n\nconst LAST_INTERACTIONS = [];\nconst INTERACTIONS_SPAN_MAP = new Map();\n\n/**\n * Start tracking INP webvital events.\n */\nfunction startTrackingINP() {\n  const performance = getBrowserPerformanceAPI();\n  if (performance && browserPerformanceTimeOrigin) {\n    const inpCallback = _trackINP();\n\n    return () => {\n      inpCallback();\n    };\n  }\n\n  return () => undefined;\n}\n\nconst INP_ENTRY_MAP = {\n  click: 'click',\n  pointerdown: 'click',\n  pointerup: 'click',\n  mousedown: 'click',\n  mouseup: 'click',\n  touchstart: 'click',\n  touchend: 'click',\n  mouseover: 'hover',\n  mouseout: 'hover',\n  mouseenter: 'hover',\n  mouseleave: 'hover',\n  pointerover: 'hover',\n  pointerout: 'hover',\n  pointerenter: 'hover',\n  pointerleave: 'hover',\n  dragstart: 'drag',\n  dragend: 'drag',\n  drag: 'drag',\n  dragenter: 'drag',\n  dragleave: 'drag',\n  dragover: 'drag',\n  drop: 'drag',\n  keydown: 'press',\n  keyup: 'press',\n  keypress: 'press',\n  input: 'press',\n};\n\n/** Starts tracking the Interaction to Next Paint on the current page. */\nfunction _trackINP() {\n  return addInpInstrumentationHandler(({ metric }) => {\n    if (metric.value == undefined) {\n      return;\n    }\n\n    const entry = metric.entries.find(entry => entry.duration === metric.value && INP_ENTRY_MAP[entry.name]);\n\n    if (!entry) {\n      return;\n    }\n\n    const { interactionId } = entry;\n    const interactionType = INP_ENTRY_MAP[entry.name];\n\n    /** Build the INP span, create an envelope from the span, and then send the envelope */\n    const startTime = msToSec((browserPerformanceTimeOrigin ) + entry.startTime);\n    const duration = msToSec(metric.value);\n    const activeSpan = getActiveSpan();\n    const rootSpan = activeSpan ? getRootSpan(activeSpan) : undefined;\n\n    // We first try to lookup the span from our INTERACTIONS_SPAN_MAP,\n    // where we cache the route per interactionId\n    const cachedSpan = interactionId != null ? INTERACTIONS_SPAN_MAP.get(interactionId) : undefined;\n\n    const spanToUse = cachedSpan || rootSpan;\n\n    // Else, we try to use the active span.\n    // Finally, we fall back to look at the transactionName on the scope\n    const routeName = spanToUse ? spanToJSON(spanToUse).description : getCurrentScope().getScopeData().transactionName;\n\n    const name = htmlTreeAsString(entry.target);\n    const attributes = dropUndefinedKeys({\n      [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto.http.browser.inp',\n      [SEMANTIC_ATTRIBUTE_SENTRY_OP]: `ui.interaction.${interactionType}`,\n      [SEMANTIC_ATTRIBUTE_EXCLUSIVE_TIME]: entry.duration,\n    });\n\n    const span = startStandaloneWebVitalSpan({\n      name,\n      transaction: routeName,\n      attributes,\n      startTime,\n    });\n\n    if (span) {\n      span.addEvent('inp', {\n        [SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_UNIT]: 'millisecond',\n        [SEMANTIC_ATTRIBUTE_SENTRY_MEASUREMENT_VALUE]: metric.value,\n      });\n\n      span.end(startTime + duration);\n    }\n  });\n}\n\n/**\n * Register a listener to cache route information for INP interactions.\n * TODO(v9): `latestRoute` no longer needs to be passed in and will be removed in v9.\n */\nfunction registerInpInteractionListener(_latestRoute) {\n  const handleEntries = ({ entries }) => {\n    const activeSpan = getActiveSpan();\n    const activeRootSpan = activeSpan && getRootSpan(activeSpan);\n\n    entries.forEach(entry => {\n      if (!isPerformanceEventTiming(entry) || !activeRootSpan) {\n        return;\n      }\n\n      const interactionId = entry.interactionId;\n      if (interactionId == null) {\n        return;\n      }\n\n      // If the interaction was already recorded before, nothing more to do\n      if (INTERACTIONS_SPAN_MAP.has(interactionId)) {\n        return;\n      }\n\n      // We keep max. 10 interactions in the list, then remove the oldest one & clean up\n      if (LAST_INTERACTIONS.length > 10) {\n        const last = LAST_INTERACTIONS.shift() ;\n        INTERACTIONS_SPAN_MAP.delete(last);\n      }\n\n      // We add the interaction to the list of recorded interactions\n      // and store the span for this interaction\n      LAST_INTERACTIONS.push(interactionId);\n      INTERACTIONS_SPAN_MAP.set(interactionId, activeRootSpan);\n    });\n  };\n\n  addPerformanceInstrumentationHandler('event', handleEntries);\n  addPerformanceInstrumentationHandler('first-input', handleEntries);\n}\n\nexport { registerInpInteractionListener, startTrackingINP };\n//# sourceMappingURL=inp.js.map\n","const getRating = (value, thresholds) => {\n  if (value > thresholds[1]) {\n    return 'poor';\n  }\n  if (value > thresholds[0]) {\n    return 'needs-improvement';\n  }\n  return 'good';\n};\n\nconst bindReporter = (\n  callback,\n  metric,\n  thresholds,\n  reportAllChanges,\n) => {\n  let prevValue;\n  let delta;\n  return (forceReport) => {\n    if (metric.value >= 0) {\n      if (forceReport || reportAllChanges) {\n        delta = metric.value - (prevValue || 0);\n\n        // Report the metric if there's a non-zero delta or if no previous\n        // value exists (which can happen in the case of the document becoming\n        // hidden when the metric value is 0).\n        // See: https://github.com/GoogleChrome/web-vitals/issues/14\n        if (delta || prevValue === undefined) {\n          prevValue = metric.value;\n          metric.delta = delta;\n          metric.rating = getRating(metric.value, thresholds);\n          callback(metric);\n        }\n      }\n    }\n  };\n};\n\nexport { bindReporter };\n//# sourceMappingURL=bindReporter.js.map\n","import { WINDOW } from '../../../types.js';\nimport { generateUniqueID } from './generateUniqueID.js';\nimport { getActivationStart } from './getActivationStart.js';\nimport { getNavigationEntry } from './getNavigationEntry.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nconst initMetric = (name, value) => {\n  const navEntry = getNavigationEntry();\n  let navigationType = 'navigate';\n\n  if (navEntry) {\n    if ((WINDOW.document && WINDOW.document.prerendering) || getActivationStart() > 0) {\n      navigationType = 'prerender';\n    } else if (WINDOW.document && WINDOW.document.wasDiscarded) {\n      navigationType = 'restore';\n    } else if (navEntry.type) {\n      navigationType = navEntry.type.replace(/_/g, '-') ;\n    }\n  }\n\n  // Use `entries` type specific for the metric.\n  const entries = [];\n\n  return {\n    name,\n    value: typeof value === 'undefined' ? -1 : value,\n    rating: 'good' , // If needed, will be updated when reported. `const` to keep the type from widening to `string`.\n    delta: 0,\n    entries,\n    id: generateUniqueID(),\n    navigationType,\n  };\n};\n\nexport { initMetric };\n//# sourceMappingURL=initMetric.js.map\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Performantly generate a unique, 30-char string by combining a version\n * number, the current timestamp with a 13-digit number integer.\n * @return {string}\n */\nconst generateUniqueID = () => {\n  return `v4-${Date.now()}-${Math.floor(Math.random() * (9e12 - 1)) + 1e12}`;\n};\n\nexport { generateUniqueID };\n//# sourceMappingURL=generateUniqueID.js.map\n","/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Takes a performance entry type and a callback function, and creates a\n * `PerformanceObserver` instance that will observe the specified entry type\n * with buffering enabled and call the callback _for each entry_.\n *\n * This function also feature-detects entry support and wraps the logic in a\n * try/catch to avoid errors in unsupporting browsers.\n */\nconst observe = (\n  type,\n  callback,\n  opts,\n) => {\n  try {\n    if (PerformanceObserver.supportedEntryTypes.includes(type)) {\n      const po = new PerformanceObserver(list => {\n        // Delay by a microtask to workaround a bug in Safari where the\n        // callback is invoked immediately, rather than in a separate task.\n        // See: https://github.com/GoogleChrome/web-vitals/issues/277\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        Promise.resolve().then(() => {\n          callback(list.getEntries() );\n        });\n      });\n      po.observe(\n        Object.assign(\n          {\n            type,\n            buffered: true,\n          },\n          opts || {},\n        ) ,\n      );\n      return po;\n    }\n  } catch (e) {\n    // Do nothing.\n  }\n  return;\n};\n\nexport { observe };\n//# sourceMappingURL=observe.js.map\n","/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst runOnce = (cb) => {\n  let called = false;\n  return () => {\n    if (!called) {\n      cb();\n      called = true;\n    }\n  };\n};\n\nexport { runOnce };\n//# sourceMappingURL=runOnce.js.map\n","import { WINDOW } from '../../../types.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nconst whenActivated = (callback) => {\n  if (WINDOW.document && WINDOW.document.prerendering) {\n    addEventListener('prerenderingchange', () => callback(), true);\n  } else {\n    callback();\n  }\n};\n\nexport { whenActivated };\n//# sourceMappingURL=whenActivated.js.map\n","import { bindReporter } from './lib/bindReporter.js';\nimport { getActivationStart } from './lib/getActivationStart.js';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { whenActivated } from './lib/whenActivated.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** Thresholds for FCP. See https://web.dev/articles/fcp#what_is_a_good_fcp_score */\nconst FCPThresholds = [1800, 3000];\n\n/**\n * Calculates the [FCP](https://web.dev/articles/fcp) value for the current page and\n * calls the `callback` function once the value is ready, along with the\n * relevant `paint` performance entry used to determine the value. The reported\n * value is a `DOMHighResTimeStamp`.\n */\nconst onFCP = (onReport, opts = {}) => {\n  whenActivated(() => {\n    const visibilityWatcher = getVisibilityWatcher();\n    const metric = initMetric('FCP');\n    let report;\n\n    const handleEntries = (entries) => {\n      entries.forEach(entry => {\n        if (entry.name === 'first-contentful-paint') {\n          po.disconnect();\n\n          // Only report if the page wasn't hidden prior to the first paint.\n          if (entry.startTime < visibilityWatcher.firstHiddenTime) {\n            // The activationStart reference is used because FCP should be\n            // relative to page activation rather than navigation start if the\n            // page was prerendered. But in cases where `activationStart` occurs\n            // after the FCP, this time should be clamped at 0.\n            metric.value = Math.max(entry.startTime - getActivationStart(), 0);\n            metric.entries.push(entry);\n            report(true);\n          }\n        }\n      });\n    };\n\n    const po = observe('paint', handleEntries);\n\n    if (po) {\n      report = bindReporter(onReport, metric, FCPThresholds, opts.reportAllChanges);\n    }\n  });\n};\n\nexport { FCPThresholds, onFCP };\n//# sourceMappingURL=onFCP.js.map\n","import { bindReporter } from './lib/bindReporter.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\nimport { runOnce } from './lib/runOnce.js';\nimport { onFCP } from './onFCP.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** Thresholds for CLS. See https://web.dev/articles/cls#what_is_a_good_cls_score */\nconst CLSThresholds = [0.1, 0.25];\n\n/**\n * Calculates the [CLS](https://web.dev/articles/cls) value for the current page and\n * calls the `callback` function once the value is ready to be reported, along\n * with all `layout-shift` performance entries that were used in the metric\n * value calculation. The reported value is a `double` (corresponding to a\n * [layout shift score](https://web.dev/articles/cls#layout_shift_score)).\n *\n * If the `reportAllChanges` configuration option is set to `true`, the\n * `callback` function will be called as soon as the value is initially\n * determined as well as any time the value changes throughout the page\n * lifespan.\n *\n * _**Important:** CLS should be continually monitored for changes throughout\n * the entire lifespan of a page—including if the user returns to the page after\n * it's been hidden/backgrounded. However, since browsers often [will not fire\n * additional callbacks once the user has backgrounded a\n * page](https://developer.chrome.com/blog/page-lifecycle-api/#advice-hidden),\n * `callback` is always called when the page's visibility state changes to\n * hidden. As a result, the `callback` function might be called multiple times\n * during the same page load._\n */\nconst onCLS = (onReport, opts = {}) => {\n  // Start monitoring FCP so we can only report CLS if FCP is also reported.\n  // Note: this is done to match the current behavior of CrUX.\n  onFCP(\n    runOnce(() => {\n      const metric = initMetric('CLS', 0);\n      let report;\n\n      let sessionValue = 0;\n      let sessionEntries = [];\n\n      const handleEntries = (entries) => {\n        entries.forEach(entry => {\n          // Only count layout shifts without recent user input.\n          if (!entry.hadRecentInput) {\n            const firstSessionEntry = sessionEntries[0];\n            const lastSessionEntry = sessionEntries[sessionEntries.length - 1];\n\n            // If the entry occurred less than 1 second after the previous entry\n            // and less than 5 seconds after the first entry in the session,\n            // include the entry in the current session. Otherwise, start a new\n            // session.\n            if (\n              sessionValue &&\n              firstSessionEntry &&\n              lastSessionEntry &&\n              entry.startTime - lastSessionEntry.startTime < 1000 &&\n              entry.startTime - firstSessionEntry.startTime < 5000\n            ) {\n              sessionValue += entry.value;\n              sessionEntries.push(entry);\n            } else {\n              sessionValue = entry.value;\n              sessionEntries = [entry];\n            }\n          }\n        });\n\n        // If the current session value is larger than the current CLS value,\n        // update CLS and the entries contributing to it.\n        if (sessionValue > metric.value) {\n          metric.value = sessionValue;\n          metric.entries = sessionEntries;\n          report();\n        }\n      };\n\n      const po = observe('layout-shift', handleEntries);\n      if (po) {\n        report = bindReporter(onReport, metric, CLSThresholds, opts.reportAllChanges);\n\n        onHidden(() => {\n          handleEntries(po.takeRecords() );\n          report(true);\n        });\n\n        // Queue a task to report (if nothing else triggers a report first).\n        // This allows CLS to be reported as soon as FCP fires when\n        // `reportAllChanges` is true.\n        setTimeout(report, 0);\n      }\n    }),\n  );\n};\n\nexport { CLSThresholds, onCLS };\n//# sourceMappingURL=getCLS.js.map\n","import { bindReporter } from './lib/bindReporter.js';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\nimport { runOnce } from './lib/runOnce.js';\nimport { whenActivated } from './lib/whenActivated.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** Thresholds for FID. See https://web.dev/articles/fid#what_is_a_good_fid_score */\nconst FIDThresholds = [100, 300];\n\n/**\n * Calculates the [FID](https://web.dev/articles/fid) value for the current page and\n * calls the `callback` function once the value is ready, along with the\n * relevant `first-input` performance entry used to determine the value. The\n * reported value is a `DOMHighResTimeStamp`.\n *\n * _**Important:** since FID is only reported after the user interacts with the\n * page, it's possible that it will not be reported for some page loads._\n */\nconst onFID = (onReport, opts = {}) => {\n  whenActivated(() => {\n    const visibilityWatcher = getVisibilityWatcher();\n    const metric = initMetric('FID');\n    // eslint-disable-next-line prefer-const\n    let report;\n\n    const handleEntry = (entry) => {\n      // Only report if the page wasn't hidden prior to the first input.\n      if (entry.startTime < visibilityWatcher.firstHiddenTime) {\n        metric.value = entry.processingStart - entry.startTime;\n        metric.entries.push(entry);\n        report(true);\n      }\n    };\n\n    const handleEntries = (entries) => {\n      (entries ).forEach(handleEntry);\n    };\n\n    const po = observe('first-input', handleEntries);\n\n    report = bindReporter(onReport, metric, FIDThresholds, opts.reportAllChanges);\n\n    if (po) {\n      onHidden(\n        runOnce(() => {\n          handleEntries(po.takeRecords() );\n          po.disconnect();\n        }),\n      );\n    }\n  });\n};\n\nexport { FIDThresholds, onFID };\n//# sourceMappingURL=getFID.js.map\n","import { observe } from '../observe.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nlet interactionCountEstimate = 0;\nlet minKnownInteractionId = Infinity;\nlet maxKnownInteractionId = 0;\n\nconst updateEstimate = (entries) => {\n  entries.forEach(e => {\n    if (e.interactionId) {\n      minKnownInteractionId = Math.min(minKnownInteractionId, e.interactionId);\n      maxKnownInteractionId = Math.max(maxKnownInteractionId, e.interactionId);\n\n      interactionCountEstimate = maxKnownInteractionId ? (maxKnownInteractionId - minKnownInteractionId) / 7 + 1 : 0;\n    }\n  });\n};\n\nlet po;\n\n/**\n * Returns the `interactionCount` value using the native API (if available)\n * or the polyfill estimate in this module.\n */\nconst getInteractionCount = () => {\n  return po ? interactionCountEstimate : performance.interactionCount || 0;\n};\n\n/**\n * Feature detects native support or initializes the polyfill if needed.\n */\nconst initInteractionCountPolyfill = () => {\n  if ('interactionCount' in performance || po) return;\n\n  po = observe('event', updateEstimate, {\n    type: 'event',\n    buffered: true,\n    durationThreshold: 0,\n  } );\n};\n\nexport { getInteractionCount, initInteractionCountPolyfill };\n//# sourceMappingURL=interactionCountPolyfill.js.map\n","import { getInteractionCount } from './polyfills/interactionCountPolyfill.js';\n\n/*\n * Copyright 2024 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n// A list of longest interactions on the page (by latency) sorted so the\n// longest one is first. The list is at most MAX_INTERACTIONS_TO_CONSIDER long.\nconst longestInteractionList = [];\n\n// A mapping of longest interactions by their interaction ID.\n// This is used for faster lookup.\nconst longestInteractionMap = new Map();\n\n// The default `durationThreshold` used across this library for observing\n// `event` entries via PerformanceObserver.\nconst DEFAULT_DURATION_THRESHOLD = 40;\n\n// Used to store the interaction count after a bfcache restore, since p98\n// interaction latencies should only consider the current navigation.\nlet prevInteractionCount = 0;\n\n/**\n * Returns the interaction count since the last bfcache restore (or for the\n * full page lifecycle if there were no bfcache restores).\n */\nconst getInteractionCountForNavigation = () => {\n  return getInteractionCount() - prevInteractionCount;\n};\n\n/**\n * Returns the estimated p98 longest interaction based on the stored\n * interaction candidates and the interaction count for the current page.\n */\nconst estimateP98LongestInteraction = () => {\n  const candidateInteractionIndex = Math.min(\n    longestInteractionList.length - 1,\n    Math.floor(getInteractionCountForNavigation() / 50),\n  );\n\n  return longestInteractionList[candidateInteractionIndex];\n};\n\n// To prevent unnecessary memory usage on pages with lots of interactions,\n// store at most 10 of the longest interactions to consider as INP candidates.\nconst MAX_INTERACTIONS_TO_CONSIDER = 10;\n\n/**\n * A list of callback functions to run before each entry is processed.\n * Exposing this list allows the attribution build to hook into the\n * entry processing pipeline.\n */\nconst entryPreProcessingCallbacks = [];\n\n/**\n * Takes a performance entry and adds it to the list of worst interactions\n * if its duration is long enough to make it among the worst. If the\n * entry is part of an existing interaction, it is merged and the latency\n * and entries list is updated as needed.\n */\nconst processInteractionEntry = (entry) => {\n  entryPreProcessingCallbacks.forEach(cb => cb(entry));\n\n  // Skip further processing for entries that cannot be INP candidates.\n  if (!(entry.interactionId || entry.entryType === 'first-input')) return;\n\n  // The least-long of the 10 longest interactions.\n  const minLongestInteraction = longestInteractionList[longestInteractionList.length - 1];\n\n  const existingInteraction = longestInteractionMap.get(entry.interactionId);\n\n  // Only process the entry if it's possibly one of the ten longest,\n  // or if it's part of an existing interaction.\n  if (\n    existingInteraction ||\n    longestInteractionList.length < MAX_INTERACTIONS_TO_CONSIDER ||\n    (minLongestInteraction && entry.duration > minLongestInteraction.latency)\n  ) {\n    // If the interaction already exists, update it. Otherwise create one.\n    if (existingInteraction) {\n      // If the new entry has a longer duration, replace the old entries,\n      // otherwise add to the array.\n      if (entry.duration > existingInteraction.latency) {\n        existingInteraction.entries = [entry];\n        existingInteraction.latency = entry.duration;\n      } else if (\n        entry.duration === existingInteraction.latency &&\n        entry.startTime === (existingInteraction.entries[0] && existingInteraction.entries[0].startTime)\n      ) {\n        existingInteraction.entries.push(entry);\n      }\n    } else {\n      const interaction = {\n        id: entry.interactionId,\n        latency: entry.duration,\n        entries: [entry],\n      };\n      longestInteractionMap.set(interaction.id, interaction);\n      longestInteractionList.push(interaction);\n    }\n\n    // Sort the entries by latency (descending) and keep only the top ten.\n    longestInteractionList.sort((a, b) => b.latency - a.latency);\n    if (longestInteractionList.length > MAX_INTERACTIONS_TO_CONSIDER) {\n      longestInteractionList.splice(MAX_INTERACTIONS_TO_CONSIDER).forEach(i => longestInteractionMap.delete(i.id));\n    }\n  }\n};\n\nexport { DEFAULT_DURATION_THRESHOLD, entryPreProcessingCallbacks, estimateP98LongestInteraction, longestInteractionList, longestInteractionMap, processInteractionEntry };\n//# sourceMappingURL=interactions.js.map\n","import { WINDOW } from '../../../types.js';\nimport { onHidden } from './onHidden.js';\nimport { runOnce } from './runOnce.js';\n\n/*\n * Copyright 2024 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/**\n * Runs the passed callback during the next idle period, or immediately\n * if the browser's visibility state is (or becomes) hidden.\n */\nconst whenIdle = (cb) => {\n  const rIC = WINDOW.requestIdleCallback || WINDOW.setTimeout;\n\n  let handle = -1;\n  // eslint-disable-next-line no-param-reassign\n  cb = runOnce(cb) ;\n  // If the document is hidden, run the callback immediately, otherwise\n  // race an idle callback with the next `visibilitychange` event.\n  if (WINDOW.document && WINDOW.document.visibilityState === 'hidden') {\n    cb();\n  } else {\n    handle = rIC(cb);\n    onHidden(cb);\n  }\n  return handle;\n};\n\nexport { whenIdle };\n//# sourceMappingURL=whenIdle.js.map\n","import { WINDOW } from '../../types.js';\nimport { bindReporter } from './lib/bindReporter.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { DEFAULT_DURATION_THRESHOLD, processInteractionEntry, estimateP98LongestInteraction } from './lib/interactions.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\nimport { initInteractionCountPolyfill } from './lib/polyfills/interactionCountPolyfill.js';\nimport { whenActivated } from './lib/whenActivated.js';\nimport { whenIdle } from './lib/whenIdle.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** Thresholds for INP. See https://web.dev/articles/inp#what_is_a_good_inp_score */\nconst INPThresholds = [200, 500];\n\n/**\n * Calculates the [INP](https://web.dev/articles/inp) value for the current\n * page and calls the `callback` function once the value is ready, along with\n * the `event` performance entries reported for that interaction. The reported\n * value is a `DOMHighResTimeStamp`.\n *\n * A custom `durationThreshold` configuration option can optionally be passed to\n * control what `event-timing` entries are considered for INP reporting. The\n * default threshold is `40`, which means INP scores of less than 40 are\n * reported as 0. Note that this will not affect your 75th percentile INP value\n * unless that value is also less than 40 (well below the recommended\n * [good](https://web.dev/articles/inp#what_is_a_good_inp_score) threshold).\n *\n * If the `reportAllChanges` configuration option is set to `true`, the\n * `callback` function will be called as soon as the value is initially\n * determined as well as any time the value changes throughout the page\n * lifespan.\n *\n * _**Important:** INP should be continually monitored for changes throughout\n * the entire lifespan of a page—including if the user returns to the page after\n * it's been hidden/backgrounded. However, since browsers often [will not fire\n * additional callbacks once the user has backgrounded a\n * page](https://developer.chrome.com/blog/page-lifecycle-api/#advice-hidden),\n * `callback` is always called when the page's visibility state changes to\n * hidden. As a result, the `callback` function might be called multiple times\n * during the same page load._\n */\nconst onINP = (onReport, opts = {}) => {\n  // Return if the browser doesn't support all APIs needed to measure INP.\n  if (!('PerformanceEventTiming' in WINDOW && 'interactionId' in PerformanceEventTiming.prototype)) {\n    return;\n  }\n\n  whenActivated(() => {\n    // TODO(philipwalton): remove once the polyfill is no longer needed.\n    initInteractionCountPolyfill();\n\n    const metric = initMetric('INP');\n    // eslint-disable-next-line prefer-const\n    let report;\n\n    const handleEntries = (entries) => {\n      // Queue the `handleEntries()` callback in the next idle task.\n      // This is needed to increase the chances that all event entries that\n      // occurred between the user interaction and the next paint\n      // have been dispatched. Note: there is currently an experiment\n      // running in Chrome (EventTimingKeypressAndCompositionInteractionId)\n      // 123+ that if rolled out fully may make this no longer necessary.\n      whenIdle(() => {\n        entries.forEach(processInteractionEntry);\n\n        const inp = estimateP98LongestInteraction();\n\n        if (inp && inp.latency !== metric.value) {\n          metric.value = inp.latency;\n          metric.entries = inp.entries;\n          report();\n        }\n      });\n    };\n\n    const po = observe('event', handleEntries, {\n      // Event Timing entries have their durations rounded to the nearest 8ms,\n      // so a duration of 40ms would be any event that spans 2.5 or more frames\n      // at 60Hz. This threshold is chosen to strike a balance between usefulness\n      // and performance. Running this callback for any interaction that spans\n      // just one or two frames is likely not worth the insight that could be\n      // gained.\n      durationThreshold: opts.durationThreshold != null ? opts.durationThreshold : DEFAULT_DURATION_THRESHOLD,\n    });\n\n    report = bindReporter(onReport, metric, INPThresholds, opts.reportAllChanges);\n\n    if (po) {\n      // Also observe entries of type `first-input`. This is useful in cases\n      // where the first interaction is less than the `durationThreshold`.\n      po.observe({ type: 'first-input', buffered: true });\n\n      onHidden(() => {\n        handleEntries(po.takeRecords() );\n        report(true);\n      });\n    }\n  });\n};\n\nexport { INPThresholds, onINP };\n//# sourceMappingURL=getINP.js.map\n","import { WINDOW } from '../../types.js';\nimport { bindReporter } from './lib/bindReporter.js';\nimport { getActivationStart } from './lib/getActivationStart.js';\nimport { getVisibilityWatcher } from './lib/getVisibilityWatcher.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { observe } from './lib/observe.js';\nimport { onHidden } from './lib/onHidden.js';\nimport { runOnce } from './lib/runOnce.js';\nimport { whenActivated } from './lib/whenActivated.js';\nimport { whenIdle } from './lib/whenIdle.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** Thresholds for LCP. See https://web.dev/articles/lcp#what_is_a_good_lcp_score */\nconst LCPThresholds = [2500, 4000];\n\nconst reportedMetricIDs = {};\n\n/**\n * Calculates the [LCP](https://web.dev/articles/lcp) value for the current page and\n * calls the `callback` function once the value is ready (along with the\n * relevant `largest-contentful-paint` performance entry used to determine the\n * value). The reported value is a `DOMHighResTimeStamp`.\n *\n * If the `reportAllChanges` configuration option is set to `true`, the\n * `callback` function will be called any time a new `largest-contentful-paint`\n * performance entry is dispatched, or once the final value of the metric has\n * been determined.\n */\nconst onLCP = (onReport, opts = {}) => {\n  whenActivated(() => {\n    const visibilityWatcher = getVisibilityWatcher();\n    const metric = initMetric('LCP');\n    let report;\n\n    const handleEntries = (entries) => {\n      // If reportAllChanges is set then call this function for each entry,\n      // otherwise only consider the last one.\n      if (!opts.reportAllChanges) {\n        // eslint-disable-next-line no-param-reassign\n        entries = entries.slice(-1);\n      }\n\n      entries.forEach(entry => {\n        // Only report if the page wasn't hidden prior to LCP.\n        if (entry.startTime < visibilityWatcher.firstHiddenTime) {\n          // The startTime attribute returns the value of the renderTime if it is\n          // not 0, and the value of the loadTime otherwise. The activationStart\n          // reference is used because LCP should be relative to page activation\n          // rather than navigation start if the page was pre-rendered. But in cases\n          // where `activationStart` occurs after the LCP, this time should be\n          // clamped at 0.\n          metric.value = Math.max(entry.startTime - getActivationStart(), 0);\n          metric.entries = [entry];\n          report();\n        }\n      });\n    };\n\n    const po = observe('largest-contentful-paint', handleEntries);\n\n    if (po) {\n      report = bindReporter(onReport, metric, LCPThresholds, opts.reportAllChanges);\n\n      const stopListening = runOnce(() => {\n        if (!reportedMetricIDs[metric.id]) {\n          handleEntries(po.takeRecords() );\n          po.disconnect();\n          reportedMetricIDs[metric.id] = true;\n          report(true);\n        }\n      });\n\n      // Stop listening after input. Note: while scrolling is an input that\n      // stops LCP observation, it's unreliable since it can be programmatically\n      // generated. See: https://github.com/GoogleChrome/web-vitals/issues/75\n      ['keydown', 'click'].forEach(type => {\n        // Wrap in a setTimeout so the callback is run in a separate task\n        // to avoid extending the keyboard/click handler to reduce INP impact\n        // https://github.com/GoogleChrome/web-vitals/issues/383\n        if (WINDOW.document) {\n          addEventListener(type, () => whenIdle(stopListening ), {\n            once: true,\n            capture: true,\n          });\n        }\n      });\n\n      onHidden(stopListening);\n    }\n  });\n};\n\nexport { LCPThresholds, onLCP };\n//# sourceMappingURL=getLCP.js.map\n","import { WINDOW } from '../../types.js';\nimport { bindReporter } from './lib/bindReporter.js';\nimport { getActivationStart } from './lib/getActivationStart.js';\nimport { getNavigationEntry } from './lib/getNavigationEntry.js';\nimport { initMetric } from './lib/initMetric.js';\nimport { whenActivated } from './lib/whenActivated.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** Thresholds for TTFB. See https://web.dev/articles/ttfb#what_is_a_good_ttfb_score */\nconst TTFBThresholds = [800, 1800];\n\n/**\n * Runs in the next task after the page is done loading and/or prerendering.\n * @param callback\n */\nconst whenReady = (callback) => {\n  if (WINDOW.document && WINDOW.document.prerendering) {\n    whenActivated(() => whenReady(callback));\n  } else if (WINDOW.document && WINDOW.document.readyState !== 'complete') {\n    addEventListener('load', () => whenReady(callback), true);\n  } else {\n    // Queue a task so the callback runs after `loadEventEnd`.\n    setTimeout(callback, 0);\n  }\n};\n\n/**\n * Calculates the [TTFB](https://web.dev/articles/ttfb) value for the\n * current page and calls the `callback` function once the page has loaded,\n * along with the relevant `navigation` performance entry used to determine the\n * value. The reported value is a `DOMHighResTimeStamp`.\n *\n * Note, this function waits until after the page is loaded to call `callback`\n * in order to ensure all properties of the `navigation` entry are populated.\n * This is useful if you want to report on other metrics exposed by the\n * [Navigation Timing API](https://w3c.github.io/navigation-timing/). For\n * example, the TTFB metric starts from the page's [time\n * origin](https://www.w3.org/TR/hr-time-2/#sec-time-origin), which means it\n * includes time spent on DNS lookup, connection negotiation, network latency,\n * and server processing time.\n */\nconst onTTFB = (onReport, opts = {}) => {\n  const metric = initMetric('TTFB');\n  const report = bindReporter(onReport, metric, TTFBThresholds, opts.reportAllChanges);\n\n  whenReady(() => {\n    const navigationEntry = getNavigationEntry();\n\n    if (navigationEntry) {\n      // The activationStart reference is used because TTFB should be\n      // relative to page activation rather than navigation start if the\n      // page was prerendered. But in cases where `activationStart` occurs\n      // after the first byte is received, this time should be clamped at 0.\n      metric.value = Math.max(navigationEntry.responseStart - getActivationStart(), 0);\n\n      metric.entries = [navigationEntry];\n      report(true);\n    }\n  });\n};\n\nexport { TTFBThresholds, onTTFB };\n//# sourceMappingURL=onTTFB.js.map\n","import { logger, getFunctionName } from '@sentry/core';\nimport { DEBUG_BUILD } from '../debug-build.js';\nimport { onCLS } from './web-vitals/getCLS.js';\nimport { onFID } from './web-vitals/getFID.js';\nimport { onINP } from './web-vitals/getINP.js';\nimport { onLCP } from './web-vitals/getLCP.js';\nimport { observe } from './web-vitals/lib/observe.js';\nimport { onTTFB } from './web-vitals/onTTFB.js';\n\nconst handlers = {};\nconst instrumented = {};\n\nlet _previousCls;\nlet _previousFid;\nlet _previousLcp;\nlet _previousTtfb;\nlet _previousInp;\n\n/**\n * Add a callback that will be triggered when a CLS metric is available.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n *\n * Pass `stopOnCallback = true` to stop listening for CLS when the cleanup callback is called.\n * This will lead to the CLS being finalized and frozen.\n */\nfunction addClsInstrumentationHandler(\n  callback,\n  stopOnCallback = false,\n) {\n  return addMetricObserver('cls', callback, instrumentCls, _previousCls, stopOnCallback);\n}\n\n/**\n * Add a callback that will be triggered when a LCP metric is available.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n *\n * Pass `stopOnCallback = true` to stop listening for LCP when the cleanup callback is called.\n * This will lead to the LCP being finalized and frozen.\n */\nfunction addLcpInstrumentationHandler(\n  callback,\n  stopOnCallback = false,\n) {\n  return addMetricObserver('lcp', callback, instrumentLcp, _previousLcp, stopOnCallback);\n}\n\n/**\n * Add a callback that will be triggered when a FID metric is available.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n */\nfunction addFidInstrumentationHandler(callback) {\n  return addMetricObserver('fid', callback, instrumentFid, _previousFid);\n}\n\n/**\n * Add a callback that will be triggered when a FID metric is available.\n */\nfunction addTtfbInstrumentationHandler(callback) {\n  return addMetricObserver('ttfb', callback, instrumentTtfb, _previousTtfb);\n}\n\n/**\n * Add a callback that will be triggered when a INP metric is available.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n */\nfunction addInpInstrumentationHandler(\n  callback,\n) {\n  return addMetricObserver('inp', callback, instrumentInp, _previousInp);\n}\n\n/**\n * Add a callback that will be triggered when a performance observer is triggered,\n * and receives the entries of the observer.\n * Returns a cleanup callback which can be called to remove the instrumentation handler.\n */\nfunction addPerformanceInstrumentationHandler(\n  type,\n  callback,\n) {\n  addHandler(type, callback);\n\n  if (!instrumented[type]) {\n    instrumentPerformanceObserver(type);\n    instrumented[type] = true;\n  }\n\n  return getCleanupCallback(type, callback);\n}\n\n/** Trigger all handlers of a given type. */\nfunction triggerHandlers(type, data) {\n  const typeHandlers = handlers[type];\n\n  if (!typeHandlers || !typeHandlers.length) {\n    return;\n  }\n\n  for (const handler of typeHandlers) {\n    try {\n      handler(data);\n    } catch (e) {\n      DEBUG_BUILD &&\n        logger.error(\n          `Error while triggering instrumentation handler.\\nType: ${type}\\nName: ${getFunctionName(handler)}\\nError:`,\n          e,\n        );\n    }\n  }\n}\n\nfunction instrumentCls() {\n  return onCLS(\n    metric => {\n      triggerHandlers('cls', {\n        metric,\n      });\n      _previousCls = metric;\n    },\n    // We want the callback to be called whenever the CLS value updates.\n    // By default, the callback is only called when the tab goes to the background.\n    { reportAllChanges: true },\n  );\n}\n\nfunction instrumentFid() {\n  return onFID(metric => {\n    triggerHandlers('fid', {\n      metric,\n    });\n    _previousFid = metric;\n  });\n}\n\nfunction instrumentLcp() {\n  return onLCP(\n    metric => {\n      triggerHandlers('lcp', {\n        metric,\n      });\n      _previousLcp = metric;\n    },\n    // We want the callback to be called whenever the LCP value updates.\n    // By default, the callback is only called when the tab goes to the background.\n    { reportAllChanges: true },\n  );\n}\n\nfunction instrumentTtfb() {\n  return onTTFB(metric => {\n    triggerHandlers('ttfb', {\n      metric,\n    });\n    _previousTtfb = metric;\n  });\n}\n\nfunction instrumentInp() {\n  return onINP(metric => {\n    triggerHandlers('inp', {\n      metric,\n    });\n    _previousInp = metric;\n  });\n}\n\nfunction addMetricObserver(\n  type,\n  callback,\n  instrumentFn,\n  previousValue,\n  stopOnCallback = false,\n) {\n  addHandler(type, callback);\n\n  let stopListening;\n\n  if (!instrumented[type]) {\n    stopListening = instrumentFn();\n    instrumented[type] = true;\n  }\n\n  if (previousValue) {\n    callback({ metric: previousValue });\n  }\n\n  return getCleanupCallback(type, callback, stopOnCallback ? stopListening : undefined);\n}\n\nfunction instrumentPerformanceObserver(type) {\n  const options = {};\n\n  // Special per-type options we want to use\n  if (type === 'event') {\n    options.durationThreshold = 0;\n  }\n\n  observe(\n    type,\n    entries => {\n      triggerHandlers(type, { entries });\n    },\n    options,\n  );\n}\n\nfunction addHandler(type, handler) {\n  handlers[type] = handlers[type] || [];\n  (handlers[type] ).push(handler);\n}\n\n// Get a callback which can be called to remove the instrumentation handler\nfunction getCleanupCallback(\n  type,\n  callback,\n  stopListening,\n) {\n  return () => {\n    if (stopListening) {\n      stopListening();\n    }\n\n    const typeHandlers = handlers[type];\n\n    if (!typeHandlers) {\n      return;\n    }\n\n    const index = typeHandlers.indexOf(callback);\n    if (index !== -1) {\n      typeHandlers.splice(index, 1);\n    }\n  };\n}\n\n/**\n * Check if a PerformanceEntry is a PerformanceEventTiming by checking for the `duration` property.\n */\nfunction isPerformanceEventTiming(entry) {\n  return 'duration' in entry;\n}\n\nexport { addClsInstrumentationHandler, addFidInstrumentationHandler, addInpInstrumentationHandler, addLcpInstrumentationHandler, addPerformanceInstrumentationHandler, addTtfbInstrumentationHandler, isPerformanceEventTiming };\n//# sourceMappingURL=instrument.js.map\n","import { spanToJSON, withActiveSpan, startInactiveSpan, getClient, getCurrentScope } from '@sentry/core';\nimport { WINDOW } from '../types.js';\n\n/**\n * Checks if a given value is a valid measurement value.\n */\nfunction isMeasurementValue(value) {\n  return typeof value === 'number' && isFinite(value);\n}\n\n/**\n * Helper function to start child on transactions. This function will make sure that the transaction will\n * use the start timestamp of the created child span if it is earlier than the transactions actual\n * start timestamp.\n */\nfunction startAndEndSpan(\n  parentSpan,\n  startTimeInSeconds,\n  endTime,\n  { ...ctx },\n) {\n  const parentStartTime = spanToJSON(parentSpan).start_timestamp;\n  if (parentStartTime && parentStartTime > startTimeInSeconds) {\n    // We can only do this for SentrySpans...\n    if (typeof (parentSpan ).updateStartTime === 'function') {\n      (parentSpan ).updateStartTime(startTimeInSeconds);\n    }\n  }\n\n  // The return value only exists for tests\n  return withActiveSpan(parentSpan, () => {\n    const span = startInactiveSpan({\n      startTime: startTimeInSeconds,\n      ...ctx,\n    });\n\n    if (span) {\n      span.end(endTime);\n    }\n\n    return span;\n  });\n}\n\n/**\n * Starts an inactive, standalone span used to send web vital values to Sentry.\n * DO NOT use this for arbitrary spans, as these spans require special handling\n * during ingestion to extract metrics.\n *\n * This function adds a bunch of attributes and data to the span that's shared\n * by all web vital standalone spans. However, you need to take care of adding\n * the actual web vital value as an event to the span. Also, you need to assign\n * a transaction name and some other values that are specific to the web vital.\n *\n * Ultimately, you also need to take care of ending the span to send it off.\n *\n * @param options\n *\n * @returns an inactive, standalone and NOT YET ended span\n */\nfunction startStandaloneWebVitalSpan(options) {\n  const client = getClient();\n  if (!client) {\n    return;\n  }\n\n  const { name, transaction, attributes: passedAttributes, startTime } = options;\n\n  const { release, environment } = client.getOptions();\n  // We need to get the replay, user, and activeTransaction from the current scope\n  // so that we can associate replay id, profile id, and a user display to the span\n  const replay = client.getIntegrationByName('Replay');\n  const replayId = replay && replay.getReplayId();\n\n  const scope = getCurrentScope();\n\n  const user = scope.getUser();\n  const userDisplay = user !== undefined ? user.email || user.id || user.ip_address : undefined;\n\n  let profileId;\n  try {\n    // @ts-expect-error skip optional chaining to save bundle size with try catch\n    profileId = scope.getScopeData().contexts.profile.profile_id;\n  } catch (e) {\n    // do nothing\n  }\n\n  const attributes = {\n    release,\n    environment,\n\n    user: userDisplay || undefined,\n    profile_id: profileId || undefined,\n    replay_id: replayId || undefined,\n\n    transaction,\n\n    // Web vital score calculation relies on the user agent to account for different\n    // browsers setting different thresholds for what is considered a good/meh/bad value.\n    // For example: Chrome vs. Chrome Mobile\n    'user_agent.original': WINDOW.navigator && WINDOW.navigator.userAgent,\n\n    ...passedAttributes,\n  };\n\n  return startInactiveSpan({\n    name,\n    attributes,\n    startTime,\n    experimental: {\n      standalone: true,\n    },\n  });\n}\n\n/** Get the browser performance API. */\nfunction getBrowserPerformanceAPI() {\n  // @ts-expect-error we want to make sure all of these are available, even if TS is sure they are\n  return WINDOW && WINDOW.addEventListener && WINDOW.performance;\n}\n\n/**\n * Converts from milliseconds to seconds\n * @param time time in ms\n */\nfunction msToSec(time) {\n  return time / 1000;\n}\n\nexport { getBrowserPerformanceAPI, isMeasurementValue, msToSec, startAndEndSpan, startStandaloneWebVitalSpan };\n//# sourceMappingURL=utils.js.map\n","import { getNavigationEntry } from './getNavigationEntry.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nconst getActivationStart = () => {\n  const navEntry = getNavigationEntry();\n  return (navEntry && navEntry.activationStart) || 0;\n};\n\nexport { getActivationStart };\n//# sourceMappingURL=getActivationStart.js.map\n","import { WINDOW } from '../../../types.js';\n\n/*\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n// sentry-specific change:\n// add optional param to not check for responseStart (see comment below)\nconst getNavigationEntry = (checkResponseStart = true) => {\n  const navigationEntry =\n    WINDOW.performance && WINDOW.performance.getEntriesByType && WINDOW.performance.getEntriesByType('navigation')[0];\n  // Check to ensure the `responseStart` property is present and valid.\n  // In some cases no value is reported by the browser (for\n  // privacy/security reasons), and in other cases (bugs) the value is\n  // negative or is larger than the current page time. Ignore these cases:\n  // https://github.com/GoogleChrome/web-vitals/issues/137\n  // https://github.com/GoogleChrome/web-vitals/issues/162\n  // https://github.com/GoogleChrome/web-vitals/issues/275\n  if (\n    // sentry-specific change:\n    // We don't want to check for responseStart for our own use of `getNavigationEntry`\n    !checkResponseStart ||\n    (navigationEntry && navigationEntry.responseStart > 0 && navigationEntry.responseStart < performance.now())\n  ) {\n    return navigationEntry;\n  }\n};\n\nexport { getNavigationEntry };\n//# sourceMappingURL=getNavigationEntry.js.map\n","import { WINDOW } from '../../../types.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nlet firstHiddenTime = -1;\n\nconst initHiddenTime = () => {\n  // If the document is hidden when this code runs, assume it was always\n  // hidden and the page was loaded in the background, with the one exception\n  // that visibility state is always 'hidden' during prerendering, so we have\n  // to ignore that case until prerendering finishes (see: `prerenderingchange`\n  // event logic below).\n  return WINDOW.document.visibilityState === 'hidden' && !WINDOW.document.prerendering ? 0 : Infinity;\n};\n\nconst onVisibilityUpdate = (event) => {\n  // If the document is 'hidden' and no previous hidden timestamp has been\n  // set, update it based on the current event data.\n  if (WINDOW.document.visibilityState === 'hidden' && firstHiddenTime > -1) {\n    // If the event is a 'visibilitychange' event, it means the page was\n    // visible prior to this change, so the event timestamp is the first\n    // hidden time.\n    // However, if the event is not a 'visibilitychange' event, then it must\n    // be a 'prerenderingchange' event, and the fact that the document is\n    // still 'hidden' from the above check means the tab was activated\n    // in a background state and so has always been hidden.\n    firstHiddenTime = event.type === 'visibilitychange' ? event.timeStamp : 0;\n\n    // Remove all listeners now that a `firstHiddenTime` value has been set.\n    removeChangeListeners();\n  }\n};\n\nconst addChangeListeners = () => {\n  addEventListener('visibilitychange', onVisibilityUpdate, true);\n  // IMPORTANT: when a page is prerendering, its `visibilityState` is\n  // 'hidden', so in order to account for cases where this module checks for\n  // visibility during prerendering, an additional check after prerendering\n  // completes is also required.\n  addEventListener('prerenderingchange', onVisibilityUpdate, true);\n};\n\nconst removeChangeListeners = () => {\n  removeEventListener('visibilitychange', onVisibilityUpdate, true);\n  removeEventListener('prerenderingchange', onVisibilityUpdate, true);\n};\n\nconst getVisibilityWatcher = () => {\n  if (WINDOW.document && firstHiddenTime < 0) {\n    // If the document is hidden when this code runs, assume it was hidden\n    // since navigation start. This isn't a perfect heuristic, but it's the\n    // best we can do until an API is available to support querying past\n    // visibilityState.\n    firstHiddenTime = initHiddenTime();\n    addChangeListeners();\n  }\n  return {\n    get firstHiddenTime() {\n      return firstHiddenTime;\n    },\n  };\n};\n\nexport { getVisibilityWatcher };\n//# sourceMappingURL=getVisibilityWatcher.js.map\n","import { WINDOW } from '../../../types.js';\n\n/*\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n// Sentry-specific change:\n// This function's logic was NOT updated to web-vitals 4.2.4 but we continue\n// to use the web-vitals 3.5.2 due to us having stricter browser support.\n// PR with context that made the changes: https://github.com/GoogleChrome/web-vitals/pull/442/files#r1530492402\n// The PR removed listening to the `pagehide` event, in favour of only listening to `visibilitychange` event.\n// This is \"more correct\" but some browsers we still support (Safari 12.1-14.0) don't fully support `visibilitychange`\n// or have known bugs w.r.t the `visibilitychange` event.\n// TODO (v9): If we decide to drop support for Safari 12.1-14.0, we can use the logic from web-vitals 4.2.4\n// In this case, we also need to update the integration tests that currently trigger the `pagehide` event to\n// simulate the page being hidden.\nconst onHidden = (cb) => {\n  const onHiddenOrPageHide = (event) => {\n    if (event.type === 'pagehide' || (WINDOW.document && WINDOW.document.visibilityState === 'hidden')) {\n      cb(event);\n    }\n  };\n\n  if (WINDOW.document) {\n    addEventListener('visibilitychange', onHiddenOrPageHide, true);\n    // Some browsers have buggy implementations of visibilitychange,\n    // so we use pagehide in addition, just to be safe.\n    addEventListener('pagehide', onHiddenOrPageHide, true);\n  }\n};\n\nexport { onHidden };\n//# sourceMappingURL=onHidden.js.map\n","import { GLOBAL_OBJ } from '@sentry/core';\n\nconst WINDOW = GLOBAL_OBJ\n\n;\n\nexport { WINDOW };\n//# sourceMappingURL=types.js.map\n","import { _nullishCoalesce, _optionalChain } from '@sentry/core';\nimport { GLOBAL_OBJ, normalize, fill, htmlTreeAsString, browserPerformanceTimeOrigin, logger as logger$1, severityLevelFromString, captureException, addBreadcrumb, uuid4, getClient, getLocationHref, getCurrentScope, getActiveSpan, getDynamicSamplingContextFromSpan, isSentryRequestUrl, dropUndefinedKeys, stringMatchesSomePattern, addEventProcessor, createEnvelope, createEventEnvelopeHeaders, getSdkMetadataForEnvelopeHeader, prepareEvent, getIsolationScope, resolvedSyncPromise, updateRateLimits, isRateLimited, setContext, getRootSpan, spanToJSON, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, isBrowser, parseSampleRate, consoleSandbox } from '@sentry/core';\nimport { setTimeout as setTimeout$3, addPerformanceInstrumentationHandler, addLcpInstrumentationHandler, addClsInstrumentationHandler, addFidInstrumentationHandler, addInpInstrumentationHandler, SENTRY_XHR_DATA_KEY, addClickKeypressInstrumentationHandler, addHistoryInstrumentationHandler } from '@sentry-internal/browser-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\nconst WINDOW = GLOBAL_OBJ ;\n\nconst REPLAY_SESSION_KEY = 'sentryReplaySession';\nconst REPLAY_EVENT_NAME = 'replay_event';\nconst UNABLE_TO_SEND_REPLAY = 'Unable to send Replay';\n\n// The idle limit for a session after which recording is paused.\nconst SESSION_IDLE_PAUSE_DURATION = 300000; // 5 minutes in ms\n\n// The idle limit for a session after which the session expires.\nconst SESSION_IDLE_EXPIRE_DURATION = 900000; // 15 minutes in ms\n\n/** Default flush delays */\nconst DEFAULT_FLUSH_MIN_DELAY = 5000;\n// XXX: Temp fix for our debounce logic where `maxWait` would never occur if it\n// was the same as `wait`\nconst DEFAULT_FLUSH_MAX_DELAY = 5500;\n\n/* How long to wait for error checkouts */\nconst BUFFER_CHECKOUT_TIME = 60000;\n\nconst RETRY_BASE_INTERVAL = 5000;\nconst RETRY_MAX_COUNT = 3;\n\n/* The max (uncompressed) size in bytes of a network body. Any body larger than this will be truncated. */\nconst NETWORK_BODY_MAX_SIZE = 150000;\n\n/* The max size of a single console arg that is captured. Any arg larger than this will be truncated. */\nconst CONSOLE_ARG_MAX_SIZE = 5000;\n\n/* Min. time to wait before we consider something a slow click. */\nconst SLOW_CLICK_THRESHOLD = 3000;\n/* For scroll actions after a click, we only look for a very short time period to detect programmatic scrolling. */\nconst 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). */\nconst REPLAY_MAX_EVENT_BUFFER_SIZE = 20000000; // ~20MB\n\n/** Replays must be min. 5s long before we send them. */\nconst MIN_REPLAY_DURATION = 4999;\n/* The max. allowed value that the minReplayDuration can be set to. */\nconst MIN_REPLAY_DURATION_LIMIT = 15000;\n\n/** The max. length of a replay. */\nconst MAX_REPLAY_DURATION = 3600000; // 60 minutes in ms;\n\nfunction _nullishCoalesce$1(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }function _optionalChain$5(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var NodeType$3;\n(function (NodeType) {\n    NodeType[NodeType[\"Document\"] = 0] = \"Document\";\n    NodeType[NodeType[\"DocumentType\"] = 1] = \"DocumentType\";\n    NodeType[NodeType[\"Element\"] = 2] = \"Element\";\n    NodeType[NodeType[\"Text\"] = 3] = \"Text\";\n    NodeType[NodeType[\"CDATA\"] = 4] = \"CDATA\";\n    NodeType[NodeType[\"Comment\"] = 5] = \"Comment\";\n})(NodeType$3 || (NodeType$3 = {}));\n\nfunction isElement$1(n) {\n    return n.nodeType === n.ELEMENT_NODE;\n}\nfunction isShadowRoot(n) {\n    const host = _optionalChain$5([n, 'optionalAccess', _ => _.host]);\n    return Boolean(_optionalChain$5([host, 'optionalAccess', _2 => _2.shadowRoot]) === n);\n}\nfunction isNativeShadowDom(shadowRoot) {\n    return Object.prototype.toString.call(shadowRoot) === '[object ShadowRoot]';\n}\nfunction fixBrowserCompatibilityIssuesInCSS(cssText) {\n    if (cssText.includes(' background-clip: text;') &&\n        !cssText.includes(' -webkit-background-clip: text;')) {\n        cssText = cssText.replace(/\\sbackground-clip:\\s*text;/g, ' -webkit-background-clip: text; background-clip: text;');\n    }\n    return cssText;\n}\nfunction escapeImportStatement(rule) {\n    const { cssText } = rule;\n    if (cssText.split('\"').length < 3)\n        return cssText;\n    const statement = ['@import', `url(${JSON.stringify(rule.href)})`];\n    if (rule.layerName === '') {\n        statement.push(`layer`);\n    }\n    else if (rule.layerName) {\n        statement.push(`layer(${rule.layerName})`);\n    }\n    if (rule.supportsText) {\n        statement.push(`supports(${rule.supportsText})`);\n    }\n    if (rule.media.length) {\n        statement.push(rule.media.mediaText);\n    }\n    return statement.join(' ') + ';';\n}\nfunction stringifyStylesheet(s) {\n    try {\n        const rules = s.rules || s.cssRules;\n        return rules\n            ? fixBrowserCompatibilityIssuesInCSS(Array.from(rules, stringifyRule).join(''))\n            : null;\n    }\n    catch (error) {\n        return null;\n    }\n}\nfunction fixAllCssProperty(rule) {\n    let styles = '';\n    for (let i = 0; i < rule.style.length; i++) {\n        const styleDeclaration = rule.style;\n        const attribute = styleDeclaration[i];\n        const isImportant = styleDeclaration.getPropertyPriority(attribute);\n        styles += `${attribute}:${styleDeclaration.getPropertyValue(attribute)}${isImportant ? ` !important` : ''};`;\n    }\n    return `${rule.selectorText} { ${styles} }`;\n}\nfunction stringifyRule(rule) {\n    let importStringified;\n    if (isCSSImportRule(rule)) {\n        try {\n            importStringified =\n                stringifyStylesheet(rule.styleSheet) ||\n                    escapeImportStatement(rule);\n        }\n        catch (error) {\n        }\n    }\n    else if (isCSSStyleRule(rule)) {\n        let cssText = rule.cssText;\n        const needsSafariColonFix = rule.selectorText.includes(':');\n        const needsAllFix = typeof rule.style['all'] === 'string' && rule.style['all'];\n        if (needsAllFix) {\n            cssText = fixAllCssProperty(rule);\n        }\n        if (needsSafariColonFix) {\n            cssText = fixSafariColons(cssText);\n        }\n        if (needsSafariColonFix || needsAllFix) {\n            return cssText;\n        }\n    }\n    return importStringified || rule.cssText;\n}\nfunction fixSafariColons(cssStringified) {\n    const regex = /(\\[(?:[\\w-]+)[^\\\\])(:(?:[\\w-]+)\\])/gm;\n    return cssStringified.replace(regex, '$1\\\\$2');\n}\nfunction isCSSImportRule(rule) {\n    return 'styleSheet' in rule;\n}\nfunction isCSSStyleRule(rule) {\n    return 'selectorText' in rule;\n}\nclass Mirror {\n    constructor() {\n        this.idNodeMap = new Map();\n        this.nodeMetaMap = new WeakMap();\n    }\n    getId(n) {\n        if (!n)\n            return -1;\n        const id = _optionalChain$5([this, 'access', _3 => _3.getMeta, 'call', _4 => _4(n), 'optionalAccess', _5 => _5.id]);\n        return _nullishCoalesce$1(id, () => ( -1));\n    }\n    getNode(id) {\n        return this.idNodeMap.get(id) || null;\n    }\n    getIds() {\n        return Array.from(this.idNodeMap.keys());\n    }\n    getMeta(n) {\n        return this.nodeMetaMap.get(n) || null;\n    }\n    removeNodeFromMap(n) {\n        const id = this.getId(n);\n        this.idNodeMap.delete(id);\n        if (n.childNodes) {\n            n.childNodes.forEach((childNode) => this.removeNodeFromMap(childNode));\n        }\n    }\n    has(id) {\n        return this.idNodeMap.has(id);\n    }\n    hasNode(node) {\n        return this.nodeMetaMap.has(node);\n    }\n    add(n, meta) {\n        const id = meta.id;\n        this.idNodeMap.set(id, n);\n        this.nodeMetaMap.set(n, meta);\n    }\n    replace(id, n) {\n        const oldNode = this.getNode(id);\n        if (oldNode) {\n            const meta = this.nodeMetaMap.get(oldNode);\n            if (meta)\n                this.nodeMetaMap.set(n, meta);\n        }\n        this.idNodeMap.set(id, n);\n    }\n    reset() {\n        this.idNodeMap = new Map();\n        this.nodeMetaMap = new WeakMap();\n    }\n}\nfunction createMirror() {\n    return new Mirror();\n}\nfunction shouldMaskInput({ maskInputOptions, tagName, type, }) {\n    if (tagName === 'OPTION') {\n        tagName = 'SELECT';\n    }\n    return Boolean(maskInputOptions[tagName.toLowerCase()] ||\n        (type && maskInputOptions[type]) ||\n        type === 'password' ||\n        (tagName === 'INPUT' && !type && maskInputOptions['text']));\n}\nfunction maskInputValue({ isMasked, element, value, maskInputFn, }) {\n    let text = value || '';\n    if (!isMasked) {\n        return text;\n    }\n    if (maskInputFn) {\n        text = maskInputFn(text, element);\n    }\n    return '*'.repeat(text.length);\n}\nfunction toLowerCase(str) {\n    return str.toLowerCase();\n}\nfunction toUpperCase(str) {\n    return str.toUpperCase();\n}\nconst ORIGINAL_ATTRIBUTE_NAME = '__rrweb_original__';\nfunction is2DCanvasBlank(canvas) {\n    const ctx = canvas.getContext('2d');\n    if (!ctx)\n        return true;\n    const chunkSize = 50;\n    for (let x = 0; x < canvas.width; x += chunkSize) {\n        for (let y = 0; y < canvas.height; y += chunkSize) {\n            const getImageData = ctx.getImageData;\n            const originalGetImageData = ORIGINAL_ATTRIBUTE_NAME in getImageData\n                ? getImageData[ORIGINAL_ATTRIBUTE_NAME]\n                : getImageData;\n            const pixelBuffer = new Uint32Array(originalGetImageData.call(ctx, x, y, Math.min(chunkSize, canvas.width - x), Math.min(chunkSize, canvas.height - y)).data.buffer);\n            if (pixelBuffer.some((pixel) => pixel !== 0))\n                return false;\n        }\n    }\n    return true;\n}\nfunction getInputType(element) {\n    const type = element.type;\n    return element.hasAttribute('data-rr-is-password')\n        ? 'password'\n        : type\n            ?\n                toLowerCase(type)\n            : null;\n}\nfunction getInputValue(el, tagName, type) {\n    if (tagName === 'INPUT' && (type === 'radio' || type === 'checkbox')) {\n        return el.getAttribute('value') || '';\n    }\n    return el.value;\n}\nfunction extractFileExtension(path, baseURL) {\n    let url;\n    try {\n        url = new URL(path, _nullishCoalesce$1(baseURL, () => ( window.location.href)));\n    }\n    catch (err) {\n        return null;\n    }\n    const regex = /\\.([0-9a-z]+)(?:$)/i;\n    const match = url.pathname.match(regex);\n    return _nullishCoalesce$1(_optionalChain$5([match, 'optionalAccess', _6 => _6[1]]), () => ( null));\n}\nconst cachedImplementations$1 = {};\nfunction getImplementation$1(name) {\n    const cached = cachedImplementations$1[name];\n    if (cached) {\n        return cached;\n    }\n    const document = window.document;\n    let impl = window[name];\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[name]) {\n                impl =\n                    contentWindow[name];\n            }\n            document.head.removeChild(sandbox);\n        }\n        catch (e) {\n        }\n    }\n    return (cachedImplementations$1[name] = impl.bind(window));\n}\nfunction setTimeout$2(...rest) {\n    return getImplementation$1('setTimeout')(...rest);\n}\nfunction clearTimeout$2(...rest) {\n    return getImplementation$1('clearTimeout')(...rest);\n}\nfunction getIframeContentDocument(iframe) {\n    try {\n        return iframe.contentDocument;\n    }\n    catch (e) {\n    }\n}\n\nlet _id = 1;\nconst tagNameRegex = new RegExp('[^a-z0-9-_:]');\nconst IGNORED_NODE = -2;\nfunction genId() {\n    return _id++;\n}\nfunction getValidTagName(element) {\n    if (element instanceof HTMLFormElement) {\n        return 'form';\n    }\n    const processedTagName = toLowerCase(element.tagName);\n    if (tagNameRegex.test(processedTagName)) {\n        return 'div';\n    }\n    return processedTagName;\n}\nfunction extractOrigin(url) {\n    let origin = '';\n    if (url.indexOf('//') > -1) {\n        origin = url.split('/').slice(0, 3).join('/');\n    }\n    else {\n        origin = url.split('/')[0];\n    }\n    origin = origin.split('?')[0];\n    return origin;\n}\nlet canvasService;\nlet canvasCtx;\nconst URL_IN_CSS_REF = /url\\((?:(')([^']*)'|(\")(.*?)\"|([^)]*))\\)/gm;\nconst URL_PROTOCOL_MATCH = /^(?:[a-z+]+:)?\\/\\//i;\nconst URL_WWW_MATCH = /^www\\..*/i;\nconst DATA_URI = /^(data:)([^,]*),(.*)/i;\nfunction absoluteToStylesheet(cssText, href) {\n    return (cssText || '').replace(URL_IN_CSS_REF, (origin, quote1, path1, quote2, path2, path3) => {\n        const filePath = path1 || path2 || path3;\n        const maybeQuote = quote1 || quote2 || '';\n        if (!filePath) {\n            return origin;\n        }\n        if (URL_PROTOCOL_MATCH.test(filePath) || URL_WWW_MATCH.test(filePath)) {\n            return `url(${maybeQuote}${filePath}${maybeQuote})`;\n        }\n        if (DATA_URI.test(filePath)) {\n            return `url(${maybeQuote}${filePath}${maybeQuote})`;\n        }\n        if (filePath[0] === '/') {\n            return `url(${maybeQuote}${extractOrigin(href) + filePath}${maybeQuote})`;\n        }\n        const stack = href.split('/');\n        const parts = filePath.split('/');\n        stack.pop();\n        for (const part of parts) {\n            if (part === '.') {\n                continue;\n            }\n            else if (part === '..') {\n                stack.pop();\n            }\n            else {\n                stack.push(part);\n            }\n        }\n        return `url(${maybeQuote}${stack.join('/')}${maybeQuote})`;\n    });\n}\nconst SRCSET_NOT_SPACES = /^[^ \\t\\n\\r\\u000c]+/;\nconst SRCSET_COMMAS_OR_SPACES = /^[, \\t\\n\\r\\u000c]+/;\nfunction getAbsoluteSrcsetString(doc, attributeValue) {\n    if (attributeValue.trim() === '') {\n        return attributeValue;\n    }\n    let pos = 0;\n    function collectCharacters(regEx) {\n        let chars;\n        const match = regEx.exec(attributeValue.substring(pos));\n        if (match) {\n            chars = match[0];\n            pos += chars.length;\n            return chars;\n        }\n        return '';\n    }\n    const output = [];\n    while (true) {\n        collectCharacters(SRCSET_COMMAS_OR_SPACES);\n        if (pos >= attributeValue.length) {\n            break;\n        }\n        let url = collectCharacters(SRCSET_NOT_SPACES);\n        if (url.slice(-1) === ',') {\n            url = absoluteToDoc(doc, url.substring(0, url.length - 1));\n            output.push(url);\n        }\n        else {\n            let descriptorsStr = '';\n            url = absoluteToDoc(doc, url);\n            let inParens = false;\n            while (true) {\n                const c = attributeValue.charAt(pos);\n                if (c === '') {\n                    output.push((url + descriptorsStr).trim());\n                    break;\n                }\n                else if (!inParens) {\n                    if (c === ',') {\n                        pos += 1;\n                        output.push((url + descriptorsStr).trim());\n                        break;\n                    }\n                    else if (c === '(') {\n                        inParens = true;\n                    }\n                }\n                else {\n                    if (c === ')') {\n                        inParens = false;\n                    }\n                }\n                descriptorsStr += c;\n                pos += 1;\n            }\n        }\n    }\n    return output.join(', ');\n}\nconst cachedDocument = new WeakMap();\nfunction absoluteToDoc(doc, attributeValue) {\n    if (!attributeValue || attributeValue.trim() === '') {\n        return attributeValue;\n    }\n    return getHref(doc, attributeValue);\n}\nfunction isSVGElement(el) {\n    return Boolean(el.tagName === 'svg' || el.ownerSVGElement);\n}\nfunction getHref(doc, customHref) {\n    let a = cachedDocument.get(doc);\n    if (!a) {\n        a = doc.createElement('a');\n        cachedDocument.set(doc, a);\n    }\n    if (!customHref) {\n        customHref = '';\n    }\n    else if (customHref.startsWith('blob:') || customHref.startsWith('data:')) {\n        return customHref;\n    }\n    a.setAttribute('href', customHref);\n    return a.href;\n}\nfunction transformAttribute(doc, tagName, name, value, element, maskAttributeFn) {\n    if (!value) {\n        return value;\n    }\n    if (name === 'src' ||\n        (name === 'href' && !(tagName === 'use' && value[0] === '#'))) {\n        return absoluteToDoc(doc, value);\n    }\n    else if (name === 'xlink:href' && value[0] !== '#') {\n        return absoluteToDoc(doc, value);\n    }\n    else if (name === 'background' &&\n        (tagName === 'table' || tagName === 'td' || tagName === 'th')) {\n        return absoluteToDoc(doc, value);\n    }\n    else if (name === 'srcset') {\n        return getAbsoluteSrcsetString(doc, value);\n    }\n    else if (name === 'style') {\n        return absoluteToStylesheet(value, getHref(doc));\n    }\n    else if (tagName === 'object' && name === 'data') {\n        return absoluteToDoc(doc, value);\n    }\n    if (typeof maskAttributeFn === 'function') {\n        return maskAttributeFn(name, value, element);\n    }\n    return value;\n}\nfunction ignoreAttribute(tagName, name, _value) {\n    return (tagName === 'video' || tagName === 'audio') && name === 'autoplay';\n}\nfunction _isBlockedElement(element, blockClass, blockSelector, unblockSelector) {\n    try {\n        if (unblockSelector && element.matches(unblockSelector)) {\n            return false;\n        }\n        if (typeof blockClass === 'string') {\n            if (element.classList.contains(blockClass)) {\n                return true;\n            }\n        }\n        else {\n            for (let eIndex = element.classList.length; eIndex--;) {\n                const className = element.classList[eIndex];\n                if (blockClass.test(className)) {\n                    return true;\n                }\n            }\n        }\n        if (blockSelector) {\n            return element.matches(blockSelector);\n        }\n    }\n    catch (e) {\n    }\n    return false;\n}\nfunction elementClassMatchesRegex(el, regex) {\n    for (let eIndex = el.classList.length; eIndex--;) {\n        const className = el.classList[eIndex];\n        if (regex.test(className)) {\n            return true;\n        }\n    }\n    return false;\n}\nfunction distanceToMatch(node, matchPredicate, limit = Infinity, distance = 0) {\n    if (!node)\n        return -1;\n    if (node.nodeType !== node.ELEMENT_NODE)\n        return -1;\n    if (distance > limit)\n        return -1;\n    if (matchPredicate(node))\n        return distance;\n    return distanceToMatch(node.parentNode, matchPredicate, limit, distance + 1);\n}\nfunction createMatchPredicate(className, selector) {\n    return (node) => {\n        const el = node;\n        if (el === null)\n            return false;\n        try {\n            if (className) {\n                if (typeof className === 'string') {\n                    if (el.matches(`.${className}`))\n                        return true;\n                }\n                else if (elementClassMatchesRegex(el, className)) {\n                    return true;\n                }\n            }\n            if (selector && el.matches(selector))\n                return true;\n            return false;\n        }\n        catch (e2) {\n            return false;\n        }\n    };\n}\nfunction needMaskingText(node, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, maskAllText) {\n    try {\n        const el = node.nodeType === node.ELEMENT_NODE\n            ? node\n            : node.parentElement;\n        if (el === null)\n            return false;\n        if (el.tagName === 'INPUT') {\n            const autocomplete = el.getAttribute('autocomplete');\n            const disallowedAutocompleteValues = [\n                'current-password',\n                'new-password',\n                'cc-number',\n                'cc-exp',\n                'cc-exp-month',\n                'cc-exp-year',\n                'cc-csc',\n            ];\n            if (disallowedAutocompleteValues.includes(autocomplete)) {\n                return true;\n            }\n        }\n        let maskDistance = -1;\n        let unmaskDistance = -1;\n        if (maskAllText) {\n            unmaskDistance = distanceToMatch(el, createMatchPredicate(unmaskTextClass, unmaskTextSelector));\n            if (unmaskDistance < 0) {\n                return true;\n            }\n            maskDistance = distanceToMatch(el, createMatchPredicate(maskTextClass, maskTextSelector), unmaskDistance >= 0 ? unmaskDistance : Infinity);\n        }\n        else {\n            maskDistance = distanceToMatch(el, createMatchPredicate(maskTextClass, maskTextSelector));\n            if (maskDistance < 0) {\n                return false;\n            }\n            unmaskDistance = distanceToMatch(el, createMatchPredicate(unmaskTextClass, unmaskTextSelector), maskDistance >= 0 ? maskDistance : Infinity);\n        }\n        return maskDistance >= 0\n            ? unmaskDistance >= 0\n                ? maskDistance <= unmaskDistance\n                : true\n            : unmaskDistance >= 0\n                ? false\n                : !!maskAllText;\n    }\n    catch (e) {\n    }\n    return !!maskAllText;\n}\nfunction onceIframeLoaded(iframeEl, listener, iframeLoadTimeout) {\n    const win = iframeEl.contentWindow;\n    if (!win) {\n        return;\n    }\n    let fired = false;\n    let readyState;\n    try {\n        readyState = win.document.readyState;\n    }\n    catch (error) {\n        return;\n    }\n    if (readyState !== 'complete') {\n        const timer = setTimeout$2(() => {\n            if (!fired) {\n                listener();\n                fired = true;\n            }\n        }, iframeLoadTimeout);\n        iframeEl.addEventListener('load', () => {\n            clearTimeout$2(timer);\n            fired = true;\n            listener();\n        });\n        return;\n    }\n    const blankUrl = 'about:blank';\n    if (win.location.href !== blankUrl ||\n        iframeEl.src === blankUrl ||\n        iframeEl.src === '') {\n        setTimeout$2(listener, 0);\n        return iframeEl.addEventListener('load', listener);\n    }\n    iframeEl.addEventListener('load', listener);\n}\nfunction onceStylesheetLoaded(link, listener, styleSheetLoadTimeout) {\n    let fired = false;\n    let styleSheetLoaded;\n    try {\n        styleSheetLoaded = link.sheet;\n    }\n    catch (error) {\n        return;\n    }\n    if (styleSheetLoaded)\n        return;\n    const timer = setTimeout$2(() => {\n        if (!fired) {\n            listener();\n            fired = true;\n        }\n    }, styleSheetLoadTimeout);\n    link.addEventListener('load', () => {\n        clearTimeout$2(timer);\n        fired = true;\n        listener();\n    });\n}\nfunction serializeNode(n, options) {\n    const { doc, mirror, blockClass, blockSelector, unblockSelector, maskAllText, maskAttributeFn, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, inlineStylesheet, maskInputOptions = {}, maskTextFn, maskInputFn, dataURLOptions = {}, inlineImages, recordCanvas, keepIframeSrcFn, newlyAddedElement = false, } = options;\n    const rootId = getRootId(doc, mirror);\n    switch (n.nodeType) {\n        case n.DOCUMENT_NODE:\n            if (n.compatMode !== 'CSS1Compat') {\n                return {\n                    type: NodeType$3.Document,\n                    childNodes: [],\n                    compatMode: n.compatMode,\n                };\n            }\n            else {\n                return {\n                    type: NodeType$3.Document,\n                    childNodes: [],\n                };\n            }\n        case n.DOCUMENT_TYPE_NODE:\n            return {\n                type: NodeType$3.DocumentType,\n                name: n.name,\n                publicId: n.publicId,\n                systemId: n.systemId,\n                rootId,\n            };\n        case n.ELEMENT_NODE:\n            return serializeElementNode(n, {\n                doc,\n                blockClass,\n                blockSelector,\n                unblockSelector,\n                inlineStylesheet,\n                maskAttributeFn,\n                maskInputOptions,\n                maskInputFn,\n                dataURLOptions,\n                inlineImages,\n                recordCanvas,\n                keepIframeSrcFn,\n                newlyAddedElement,\n                rootId,\n                maskAllText,\n                maskTextClass,\n                unmaskTextClass,\n                maskTextSelector,\n                unmaskTextSelector,\n            });\n        case n.TEXT_NODE:\n            return serializeTextNode(n, {\n                doc,\n                maskAllText,\n                maskTextClass,\n                unmaskTextClass,\n                maskTextSelector,\n                unmaskTextSelector,\n                maskTextFn,\n                maskInputOptions,\n                maskInputFn,\n                rootId,\n            });\n        case n.CDATA_SECTION_NODE:\n            return {\n                type: NodeType$3.CDATA,\n                textContent: '',\n                rootId,\n            };\n        case n.COMMENT_NODE:\n            return {\n                type: NodeType$3.Comment,\n                textContent: n.textContent || '',\n                rootId,\n            };\n        default:\n            return false;\n    }\n}\nfunction getRootId(doc, mirror) {\n    if (!mirror.hasNode(doc))\n        return undefined;\n    const docId = mirror.getId(doc);\n    return docId === 1 ? undefined : docId;\n}\nfunction serializeTextNode(n, options) {\n    const { maskAllText, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, maskTextFn, maskInputOptions, maskInputFn, rootId, } = options;\n    const parentTagName = n.parentNode && n.parentNode.tagName;\n    let textContent = n.textContent;\n    const isStyle = parentTagName === 'STYLE' ? true : undefined;\n    const isScript = parentTagName === 'SCRIPT' ? true : undefined;\n    const isTextarea = parentTagName === 'TEXTAREA' ? true : undefined;\n    if (isStyle && textContent) {\n        try {\n            if (n.nextSibling || n.previousSibling) {\n            }\n            else if (_optionalChain$5([n, 'access', _7 => _7.parentNode, 'access', _8 => _8.sheet, 'optionalAccess', _9 => _9.cssRules])) {\n                textContent = stringifyStylesheet(n.parentNode.sheet);\n            }\n        }\n        catch (err) {\n            console.warn(`Cannot get CSS styles from text's parentNode. Error: ${err}`, n);\n        }\n        textContent = absoluteToStylesheet(textContent, getHref(options.doc));\n    }\n    if (isScript) {\n        textContent = 'SCRIPT_PLACEHOLDER';\n    }\n    const forceMask = needMaskingText(n, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, maskAllText);\n    if (!isStyle && !isScript && !isTextarea && textContent && forceMask) {\n        textContent = maskTextFn\n            ? maskTextFn(textContent, n.parentElement)\n            : textContent.replace(/[\\S]/g, '*');\n    }\n    if (isTextarea && textContent && (maskInputOptions.textarea || forceMask)) {\n        textContent = maskInputFn\n            ? maskInputFn(textContent, n.parentNode)\n            : textContent.replace(/[\\S]/g, '*');\n    }\n    if (parentTagName === 'OPTION' && textContent) {\n        const isInputMasked = shouldMaskInput({\n            type: null,\n            tagName: parentTagName,\n            maskInputOptions,\n        });\n        textContent = maskInputValue({\n            isMasked: needMaskingText(n, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, isInputMasked),\n            element: n,\n            value: textContent,\n            maskInputFn,\n        });\n    }\n    return {\n        type: NodeType$3.Text,\n        textContent: textContent || '',\n        isStyle,\n        rootId,\n    };\n}\nfunction serializeElementNode(n, options) {\n    const { doc, blockClass, blockSelector, unblockSelector, inlineStylesheet, maskInputOptions = {}, maskAttributeFn, maskInputFn, dataURLOptions = {}, inlineImages, recordCanvas, keepIframeSrcFn, newlyAddedElement = false, rootId, maskAllText, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, } = options;\n    const needBlock = _isBlockedElement(n, blockClass, blockSelector, unblockSelector);\n    const tagName = getValidTagName(n);\n    let attributes = {};\n    const len = n.attributes.length;\n    for (let i = 0; i < len; i++) {\n        const attr = n.attributes[i];\n        if (attr.name && !ignoreAttribute(tagName, attr.name, attr.value)) {\n            attributes[attr.name] = transformAttribute(doc, tagName, toLowerCase(attr.name), attr.value, n, maskAttributeFn);\n        }\n    }\n    if (tagName === 'link' && inlineStylesheet) {\n        const stylesheet = Array.from(doc.styleSheets).find((s) => {\n            return s.href === n.href;\n        });\n        let cssText = null;\n        if (stylesheet) {\n            cssText = stringifyStylesheet(stylesheet);\n        }\n        if (cssText) {\n            attributes.rel = null;\n            attributes.href = null;\n            attributes.crossorigin = null;\n            attributes._cssText = absoluteToStylesheet(cssText, stylesheet.href);\n        }\n    }\n    if (tagName === 'style' &&\n        n.sheet &&\n        !(n.innerText || n.textContent || '').trim().length) {\n        const cssText = stringifyStylesheet(n.sheet);\n        if (cssText) {\n            attributes._cssText = absoluteToStylesheet(cssText, getHref(doc));\n        }\n    }\n    if (tagName === 'input' ||\n        tagName === 'textarea' ||\n        tagName === 'select' ||\n        tagName === 'option') {\n        const el = n;\n        const type = getInputType(el);\n        const value = getInputValue(el, toUpperCase(tagName), type);\n        const checked = el.checked;\n        if (type !== 'submit' && type !== 'button' && value) {\n            const forceMask = needMaskingText(el, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, shouldMaskInput({\n                type,\n                tagName: toUpperCase(tagName),\n                maskInputOptions,\n            }));\n            attributes.value = maskInputValue({\n                isMasked: forceMask,\n                element: el,\n                value,\n                maskInputFn,\n            });\n        }\n        if (checked) {\n            attributes.checked = checked;\n        }\n    }\n    if (tagName === 'option') {\n        if (n.selected && !maskInputOptions['select']) {\n            attributes.selected = true;\n        }\n        else {\n            delete attributes.selected;\n        }\n    }\n    if (tagName === 'canvas' && recordCanvas) {\n        if (n.__context === '2d') {\n            if (!is2DCanvasBlank(n)) {\n                attributes.rr_dataURL = n.toDataURL(dataURLOptions.type, dataURLOptions.quality);\n            }\n        }\n        else if (!('__context' in n)) {\n            const canvasDataURL = n.toDataURL(dataURLOptions.type, dataURLOptions.quality);\n            const blankCanvas = doc.createElement('canvas');\n            blankCanvas.width = n.width;\n            blankCanvas.height = n.height;\n            const blankCanvasDataURL = blankCanvas.toDataURL(dataURLOptions.type, dataURLOptions.quality);\n            if (canvasDataURL !== blankCanvasDataURL) {\n                attributes.rr_dataURL = canvasDataURL;\n            }\n        }\n    }\n    if (tagName === 'img' && inlineImages) {\n        if (!canvasService) {\n            canvasService = doc.createElement('canvas');\n            canvasCtx = canvasService.getContext('2d');\n        }\n        const image = n;\n        const imageSrc = image.currentSrc || image.getAttribute('src') || '<unknown-src>';\n        const priorCrossOrigin = image.crossOrigin;\n        const recordInlineImage = () => {\n            image.removeEventListener('load', recordInlineImage);\n            try {\n                canvasService.width = image.naturalWidth;\n                canvasService.height = image.naturalHeight;\n                canvasCtx.drawImage(image, 0, 0);\n                attributes.rr_dataURL = canvasService.toDataURL(dataURLOptions.type, dataURLOptions.quality);\n            }\n            catch (err) {\n                if (image.crossOrigin !== 'anonymous') {\n                    image.crossOrigin = 'anonymous';\n                    if (image.complete && image.naturalWidth !== 0)\n                        recordInlineImage();\n                    else\n                        image.addEventListener('load', recordInlineImage);\n                    return;\n                }\n                else {\n                    console.warn(`Cannot inline img src=${imageSrc}! Error: ${err}`);\n                }\n            }\n            if (image.crossOrigin === 'anonymous') {\n                priorCrossOrigin\n                    ? (attributes.crossOrigin = priorCrossOrigin)\n                    : image.removeAttribute('crossorigin');\n            }\n        };\n        if (image.complete && image.naturalWidth !== 0)\n            recordInlineImage();\n        else\n            image.addEventListener('load', recordInlineImage);\n    }\n    if (tagName === 'audio' || tagName === 'video') {\n        attributes.rr_mediaState = n.paused\n            ? 'paused'\n            : 'played';\n        attributes.rr_mediaCurrentTime = n.currentTime;\n    }\n    if (!newlyAddedElement) {\n        if (n.scrollLeft) {\n            attributes.rr_scrollLeft = n.scrollLeft;\n        }\n        if (n.scrollTop) {\n            attributes.rr_scrollTop = n.scrollTop;\n        }\n    }\n    if (needBlock) {\n        const { width, height } = n.getBoundingClientRect();\n        attributes = {\n            class: attributes.class,\n            rr_width: `${width}px`,\n            rr_height: `${height}px`,\n        };\n    }\n    if (tagName === 'iframe' && !keepIframeSrcFn(attributes.src)) {\n        if (!needBlock && !getIframeContentDocument(n)) {\n            attributes.rr_src = attributes.src;\n        }\n        delete attributes.src;\n    }\n    let isCustomElement;\n    try {\n        if (customElements.get(tagName))\n            isCustomElement = true;\n    }\n    catch (e) {\n    }\n    return {\n        type: NodeType$3.Element,\n        tagName,\n        attributes,\n        childNodes: [],\n        isSVG: isSVGElement(n) || undefined,\n        needBlock,\n        rootId,\n        isCustom: isCustomElement,\n    };\n}\nfunction lowerIfExists(maybeAttr) {\n    if (maybeAttr === undefined || maybeAttr === null) {\n        return '';\n    }\n    else {\n        return maybeAttr.toLowerCase();\n    }\n}\nfunction slimDOMExcluded(sn, slimDOMOptions) {\n    if (slimDOMOptions.comment && sn.type === NodeType$3.Comment) {\n        return true;\n    }\n    else if (sn.type === NodeType$3.Element) {\n        if (slimDOMOptions.script &&\n            (sn.tagName === 'script' ||\n                (sn.tagName === 'link' &&\n                    (sn.attributes.rel === 'preload' ||\n                        sn.attributes.rel === 'modulepreload')) ||\n                (sn.tagName === 'link' &&\n                    sn.attributes.rel === 'prefetch' &&\n                    typeof sn.attributes.href === 'string' &&\n                    extractFileExtension(sn.attributes.href) === 'js'))) {\n            return true;\n        }\n        else if (slimDOMOptions.headFavicon &&\n            ((sn.tagName === 'link' && sn.attributes.rel === 'shortcut icon') ||\n                (sn.tagName === 'meta' &&\n                    (lowerIfExists(sn.attributes.name).match(/^msapplication-tile(image|color)$/) ||\n                        lowerIfExists(sn.attributes.name) === 'application-name' ||\n                        lowerIfExists(sn.attributes.rel) === 'icon' ||\n                        lowerIfExists(sn.attributes.rel) === 'apple-touch-icon' ||\n                        lowerIfExists(sn.attributes.rel) === 'shortcut icon')))) {\n            return true;\n        }\n        else if (sn.tagName === 'meta') {\n            if (slimDOMOptions.headMetaDescKeywords &&\n                lowerIfExists(sn.attributes.name).match(/^description|keywords$/)) {\n                return true;\n            }\n            else if (slimDOMOptions.headMetaSocial &&\n                (lowerIfExists(sn.attributes.property).match(/^(og|twitter|fb):/) ||\n                    lowerIfExists(sn.attributes.name).match(/^(og|twitter):/) ||\n                    lowerIfExists(sn.attributes.name) === 'pinterest')) {\n                return true;\n            }\n            else if (slimDOMOptions.headMetaRobots &&\n                (lowerIfExists(sn.attributes.name) === 'robots' ||\n                    lowerIfExists(sn.attributes.name) === 'googlebot' ||\n                    lowerIfExists(sn.attributes.name) === 'bingbot')) {\n                return true;\n            }\n            else if (slimDOMOptions.headMetaHttpEquiv &&\n                sn.attributes['http-equiv'] !== undefined) {\n                return true;\n            }\n            else if (slimDOMOptions.headMetaAuthorship &&\n                (lowerIfExists(sn.attributes.name) === 'author' ||\n                    lowerIfExists(sn.attributes.name) === 'generator' ||\n                    lowerIfExists(sn.attributes.name) === 'framework' ||\n                    lowerIfExists(sn.attributes.name) === 'publisher' ||\n                    lowerIfExists(sn.attributes.name) === 'progid' ||\n                    lowerIfExists(sn.attributes.property).match(/^article:/) ||\n                    lowerIfExists(sn.attributes.property).match(/^product:/))) {\n                return true;\n            }\n            else if (slimDOMOptions.headMetaVerification &&\n                (lowerIfExists(sn.attributes.name) === 'google-site-verification' ||\n                    lowerIfExists(sn.attributes.name) === 'yandex-verification' ||\n                    lowerIfExists(sn.attributes.name) === 'csrf-token' ||\n                    lowerIfExists(sn.attributes.name) === 'p:domain_verify' ||\n                    lowerIfExists(sn.attributes.name) === 'verify-v1' ||\n                    lowerIfExists(sn.attributes.name) === 'verification' ||\n                    lowerIfExists(sn.attributes.name) === 'shopify-checkout-api-token')) {\n                return true;\n            }\n        }\n    }\n    return false;\n}\nfunction serializeNodeWithId(n, options) {\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;\n    let { preserveWhiteSpace = true } = options;\n    const _serializedNode = serializeNode(n, {\n        doc,\n        mirror,\n        blockClass,\n        blockSelector,\n        maskAllText,\n        unblockSelector,\n        maskTextClass,\n        unmaskTextClass,\n        maskTextSelector,\n        unmaskTextSelector,\n        inlineStylesheet,\n        maskInputOptions,\n        maskAttributeFn,\n        maskTextFn,\n        maskInputFn,\n        dataURLOptions,\n        inlineImages,\n        recordCanvas,\n        keepIframeSrcFn,\n        newlyAddedElement,\n    });\n    if (!_serializedNode) {\n        console.warn(n, 'not serialized');\n        return null;\n    }\n    let id;\n    if (mirror.hasNode(n)) {\n        id = mirror.getId(n);\n    }\n    else if (slimDOMExcluded(_serializedNode, slimDOMOptions) ||\n        (!preserveWhiteSpace &&\n            _serializedNode.type === NodeType$3.Text &&\n            !_serializedNode.isStyle &&\n            !_serializedNode.textContent.replace(/^\\s+|\\s+$/gm, '').length)) {\n        id = IGNORED_NODE;\n    }\n    else {\n        id = genId();\n    }\n    const serializedNode = Object.assign(_serializedNode, { id });\n    mirror.add(n, serializedNode);\n    if (id === IGNORED_NODE) {\n        return null;\n    }\n    if (onSerialize) {\n        onSerialize(n);\n    }\n    let recordChild = !skipChild;\n    if (serializedNode.type === NodeType$3.Element) {\n        recordChild = recordChild && !serializedNode.needBlock;\n        delete serializedNode.needBlock;\n        const shadowRoot = n.shadowRoot;\n        if (shadowRoot && isNativeShadowDom(shadowRoot))\n            serializedNode.isShadowHost = true;\n    }\n    if ((serializedNode.type === NodeType$3.Document ||\n        serializedNode.type === NodeType$3.Element) &&\n        recordChild) {\n        if (slimDOMOptions.headWhitespace &&\n            serializedNode.type === NodeType$3.Element &&\n            serializedNode.tagName === 'head') {\n            preserveWhiteSpace = false;\n        }\n        const bypassOptions = {\n            doc,\n            mirror,\n            blockClass,\n            blockSelector,\n            maskAllText,\n            unblockSelector,\n            maskTextClass,\n            unmaskTextClass,\n            maskTextSelector,\n            unmaskTextSelector,\n            skipChild,\n            inlineStylesheet,\n            maskInputOptions,\n            maskAttributeFn,\n            maskTextFn,\n            maskInputFn,\n            slimDOMOptions,\n            dataURLOptions,\n            inlineImages,\n            recordCanvas,\n            preserveWhiteSpace,\n            onSerialize,\n            onIframeLoad,\n            iframeLoadTimeout,\n            onStylesheetLoad,\n            stylesheetLoadTimeout,\n            keepIframeSrcFn,\n        };\n        for (const childN of Array.from(n.childNodes)) {\n            const serializedChildNode = serializeNodeWithId(childN, bypassOptions);\n            if (serializedChildNode) {\n                serializedNode.childNodes.push(serializedChildNode);\n            }\n        }\n        if (isElement$1(n) && n.shadowRoot) {\n            for (const childN of Array.from(n.shadowRoot.childNodes)) {\n                const serializedChildNode = serializeNodeWithId(childN, bypassOptions);\n                if (serializedChildNode) {\n                    isNativeShadowDom(n.shadowRoot) &&\n                        (serializedChildNode.isShadow = true);\n                    serializedNode.childNodes.push(serializedChildNode);\n                }\n            }\n        }\n    }\n    if (n.parentNode &&\n        isShadowRoot(n.parentNode) &&\n        isNativeShadowDom(n.parentNode)) {\n        serializedNode.isShadow = true;\n    }\n    if (serializedNode.type === NodeType$3.Element &&\n        serializedNode.tagName === 'iframe') {\n        onceIframeLoaded(n, () => {\n            const iframeDoc = getIframeContentDocument(n);\n            if (iframeDoc && onIframeLoad) {\n                const serializedIframeNode = serializeNodeWithId(iframeDoc, {\n                    doc: iframeDoc,\n                    mirror,\n                    blockClass,\n                    blockSelector,\n                    unblockSelector,\n                    maskAllText,\n                    maskTextClass,\n                    unmaskTextClass,\n                    maskTextSelector,\n                    unmaskTextSelector,\n                    skipChild: false,\n                    inlineStylesheet,\n                    maskInputOptions,\n                    maskAttributeFn,\n                    maskTextFn,\n                    maskInputFn,\n                    slimDOMOptions,\n                    dataURLOptions,\n                    inlineImages,\n                    recordCanvas,\n                    preserveWhiteSpace,\n                    onSerialize,\n                    onIframeLoad,\n                    iframeLoadTimeout,\n                    onStylesheetLoad,\n                    stylesheetLoadTimeout,\n                    keepIframeSrcFn,\n                });\n                if (serializedIframeNode) {\n                    onIframeLoad(n, serializedIframeNode);\n                }\n            }\n        }, iframeLoadTimeout);\n    }\n    if (serializedNode.type === NodeType$3.Element &&\n        serializedNode.tagName === 'link' &&\n        typeof serializedNode.attributes.rel === 'string' &&\n        (serializedNode.attributes.rel === 'stylesheet' ||\n            (serializedNode.attributes.rel === 'preload' &&\n                typeof serializedNode.attributes.href === 'string' &&\n                extractFileExtension(serializedNode.attributes.href) === 'css'))) {\n        onceStylesheetLoaded(n, () => {\n            if (onStylesheetLoad) {\n                const serializedLinkNode = serializeNodeWithId(n, {\n                    doc,\n                    mirror,\n                    blockClass,\n                    blockSelector,\n                    unblockSelector,\n                    maskAllText,\n                    maskTextClass,\n                    unmaskTextClass,\n                    maskTextSelector,\n                    unmaskTextSelector,\n                    skipChild: false,\n                    inlineStylesheet,\n                    maskInputOptions,\n                    maskAttributeFn,\n                    maskTextFn,\n                    maskInputFn,\n                    slimDOMOptions,\n                    dataURLOptions,\n                    inlineImages,\n                    recordCanvas,\n                    preserveWhiteSpace,\n                    onSerialize,\n                    onIframeLoad,\n                    iframeLoadTimeout,\n                    onStylesheetLoad,\n                    stylesheetLoadTimeout,\n                    keepIframeSrcFn,\n                });\n                if (serializedLinkNode) {\n                    onStylesheetLoad(n, serializedLinkNode);\n                }\n            }\n        }, stylesheetLoadTimeout);\n    }\n    return serializedNode;\n}\nfunction snapshot(n, options) {\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 || {};\n    const maskInputOptions = maskAllInputs === true\n        ? {\n            color: true,\n            date: true,\n            'datetime-local': true,\n            email: true,\n            month: true,\n            number: true,\n            range: true,\n            search: true,\n            tel: true,\n            text: true,\n            time: true,\n            url: true,\n            week: true,\n            textarea: true,\n            select: true,\n        }\n        : maskAllInputs === false\n            ? {}\n            : maskAllInputs;\n    const slimDOMOptions = slimDOM === true || slimDOM === 'all'\n        ?\n            {\n                script: true,\n                comment: true,\n                headFavicon: true,\n                headWhitespace: true,\n                headMetaDescKeywords: slimDOM === 'all',\n                headMetaSocial: true,\n                headMetaRobots: true,\n                headMetaHttpEquiv: true,\n                headMetaAuthorship: true,\n                headMetaVerification: true,\n            }\n        : slimDOM === false\n            ? {}\n            : slimDOM;\n    return serializeNodeWithId(n, {\n        doc: n,\n        mirror,\n        blockClass,\n        blockSelector,\n        unblockSelector,\n        maskAllText,\n        maskTextClass,\n        unmaskTextClass,\n        maskTextSelector,\n        unmaskTextSelector,\n        skipChild: false,\n        inlineStylesheet,\n        maskInputOptions,\n        maskAttributeFn,\n        maskTextFn,\n        maskInputFn,\n        slimDOMOptions,\n        dataURLOptions,\n        inlineImages,\n        recordCanvas,\n        preserveWhiteSpace,\n        onSerialize,\n        onIframeLoad,\n        iframeLoadTimeout,\n        onStylesheetLoad,\n        stylesheetLoadTimeout,\n        keepIframeSrcFn,\n        newlyAddedElement: false,\n    });\n}\n\nfunction _optionalChain$4(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }\nfunction on(type, fn, target = document) {\n    const options = { capture: true, passive: true };\n    target.addEventListener(type, fn, options);\n    return () => target.removeEventListener(type, fn, options);\n}\nconst DEPARTED_MIRROR_ACCESS_WARNING = 'Please stop import mirror directly. Instead of that,' +\n    '\\r\\n' +\n    'now you can use replayer.getMirror() to access the mirror instance of a replayer,' +\n    '\\r\\n' +\n    'or you can use record.mirror to access the mirror instance during recording.';\nlet _mirror = {\n    map: {},\n    getId() {\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n        return -1;\n    },\n    getNode() {\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n        return null;\n    },\n    removeNodeFromMap() {\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n    },\n    has() {\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n        return false;\n    },\n    reset() {\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n    },\n};\nif (typeof window !== 'undefined' && window.Proxy && window.Reflect) {\n    _mirror = new Proxy(_mirror, {\n        get(target, prop, receiver) {\n            if (prop === 'map') {\n                console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n            }\n            return Reflect.get(target, prop, receiver);\n        },\n    });\n}\nfunction throttle$1(func, wait, options = {}) {\n    let timeout = null;\n    let previous = 0;\n    return function (...args) {\n        const now = Date.now();\n        if (!previous && options.leading === false) {\n            previous = now;\n        }\n        const remaining = wait - (now - previous);\n        const context = this;\n        if (remaining <= 0 || remaining > wait) {\n            if (timeout) {\n                clearTimeout$1(timeout);\n                timeout = null;\n            }\n            previous = now;\n            func.apply(context, args);\n        }\n        else if (!timeout && options.trailing !== false) {\n            timeout = setTimeout$1(() => {\n                previous = options.leading === false ? 0 : Date.now();\n                timeout = null;\n                func.apply(context, args);\n            }, remaining);\n        }\n    };\n}\nfunction hookSetter(target, key, d, isRevoked, win = window) {\n    const original = win.Object.getOwnPropertyDescriptor(target, key);\n    win.Object.defineProperty(target, key, isRevoked\n        ? d\n        : {\n            set(value) {\n                setTimeout$1(() => {\n                    d.set.call(this, value);\n                }, 0);\n                if (original && original.set) {\n                    original.set.call(this, value);\n                }\n            },\n        });\n    return () => hookSetter(target, key, original || {}, true);\n}\nfunction patch(source, name, replacement) {\n    try {\n        if (!(name in source)) {\n            return () => {\n            };\n        }\n        const original = source[name];\n        const wrapped = replacement(original);\n        if (typeof wrapped === 'function') {\n            wrapped.prototype = wrapped.prototype || {};\n            Object.defineProperties(wrapped, {\n                __rrweb_original__: {\n                    enumerable: false,\n                    value: original,\n                },\n            });\n        }\n        source[name] = wrapped;\n        return () => {\n            source[name] = original;\n        };\n    }\n    catch (e2) {\n        return () => {\n        };\n    }\n}\nlet nowTimestamp = Date.now;\nif (!(/[1-9][0-9]{12}/.test(Date.now().toString()))) {\n    nowTimestamp = () => new Date().getTime();\n}\nfunction getWindowScroll(win) {\n    const doc = win.document;\n    return {\n        left: doc.scrollingElement\n            ? doc.scrollingElement.scrollLeft\n            : win.pageXOffset !== undefined\n                ? win.pageXOffset\n                : _optionalChain$4([doc, 'optionalAccess', _ => _.documentElement, 'access', _2 => _2.scrollLeft]) ||\n                    _optionalChain$4([doc, 'optionalAccess', _3 => _3.body, 'optionalAccess', _4 => _4.parentElement, 'optionalAccess', _5 => _5.scrollLeft]) ||\n                    _optionalChain$4([doc, 'optionalAccess', _6 => _6.body, 'optionalAccess', _7 => _7.scrollLeft]) ||\n                    0,\n        top: doc.scrollingElement\n            ? doc.scrollingElement.scrollTop\n            : win.pageYOffset !== undefined\n                ? win.pageYOffset\n                : _optionalChain$4([doc, 'optionalAccess', _8 => _8.documentElement, 'access', _9 => _9.scrollTop]) ||\n                    _optionalChain$4([doc, 'optionalAccess', _10 => _10.body, 'optionalAccess', _11 => _11.parentElement, 'optionalAccess', _12 => _12.scrollTop]) ||\n                    _optionalChain$4([doc, 'optionalAccess', _13 => _13.body, 'optionalAccess', _14 => _14.scrollTop]) ||\n                    0,\n    };\n}\nfunction getWindowHeight() {\n    return (window.innerHeight ||\n        (document.documentElement && document.documentElement.clientHeight) ||\n        (document.body && document.body.clientHeight));\n}\nfunction getWindowWidth() {\n    return (window.innerWidth ||\n        (document.documentElement && document.documentElement.clientWidth) ||\n        (document.body && document.body.clientWidth));\n}\nfunction closestElementOfNode(node) {\n    if (!node) {\n        return null;\n    }\n    const el = node.nodeType === node.ELEMENT_NODE\n        ? node\n        : node.parentElement;\n    return el;\n}\nfunction isBlocked(node, blockClass, blockSelector, unblockSelector, checkAncestors) {\n    if (!node) {\n        return false;\n    }\n    const el = closestElementOfNode(node);\n    if (!el) {\n        return false;\n    }\n    const blockedPredicate = createMatchPredicate(blockClass, blockSelector);\n    if (!checkAncestors) {\n        const isUnblocked = unblockSelector && el.matches(unblockSelector);\n        return blockedPredicate(el) && !isUnblocked;\n    }\n    const blockDistance = distanceToMatch(el, blockedPredicate);\n    let unblockDistance = -1;\n    if (blockDistance < 0) {\n        return false;\n    }\n    if (unblockSelector) {\n        unblockDistance = distanceToMatch(el, createMatchPredicate(null, unblockSelector));\n    }\n    if (blockDistance > -1 && unblockDistance < 0) {\n        return true;\n    }\n    return blockDistance < unblockDistance;\n}\nfunction isSerialized(n, mirror) {\n    return mirror.getId(n) !== -1;\n}\nfunction isIgnored(n, mirror) {\n    return mirror.getId(n) === IGNORED_NODE;\n}\nfunction isAncestorRemoved(target, mirror) {\n    if (isShadowRoot(target)) {\n        return false;\n    }\n    const id = mirror.getId(target);\n    if (!mirror.has(id)) {\n        return true;\n    }\n    if (target.parentNode &&\n        target.parentNode.nodeType === target.DOCUMENT_NODE) {\n        return false;\n    }\n    if (!target.parentNode) {\n        return true;\n    }\n    return isAncestorRemoved(target.parentNode, mirror);\n}\nfunction legacy_isTouchEvent(event) {\n    return Boolean(event.changedTouches);\n}\nfunction polyfill(win = window) {\n    if ('NodeList' in win && !win.NodeList.prototype.forEach) {\n        win.NodeList.prototype.forEach = Array.prototype\n            .forEach;\n    }\n    if ('DOMTokenList' in win && !win.DOMTokenList.prototype.forEach) {\n        win.DOMTokenList.prototype.forEach = Array.prototype\n            .forEach;\n    }\n    if (!Node.prototype.contains) {\n        Node.prototype.contains = (...args) => {\n            let node = args[0];\n            if (!(0 in args)) {\n                throw new TypeError('1 argument is required');\n            }\n            do {\n                if (this === node) {\n                    return true;\n                }\n            } while ((node = node && node.parentNode));\n            return false;\n        };\n    }\n}\nfunction isSerializedIframe(n, mirror) {\n    return Boolean(n.nodeName === 'IFRAME' && mirror.getMeta(n));\n}\nfunction isSerializedStylesheet(n, mirror) {\n    return Boolean(n.nodeName === 'LINK' &&\n        n.nodeType === n.ELEMENT_NODE &&\n        n.getAttribute &&\n        n.getAttribute('rel') === 'stylesheet' &&\n        mirror.getMeta(n));\n}\nfunction hasShadowRoot(n) {\n    return Boolean(_optionalChain$4([n, 'optionalAccess', _18 => _18.shadowRoot]));\n}\nclass StyleSheetMirror {\n    constructor() {\n        this.id = 1;\n        this.styleIDMap = new WeakMap();\n        this.idStyleMap = new Map();\n    }\n    getId(stylesheet) {\n        return _nullishCoalesce(this.styleIDMap.get(stylesheet), () => ( -1));\n    }\n    has(stylesheet) {\n        return this.styleIDMap.has(stylesheet);\n    }\n    add(stylesheet, id) {\n        if (this.has(stylesheet))\n            return this.getId(stylesheet);\n        let newId;\n        if (id === undefined) {\n            newId = this.id++;\n        }\n        else\n            newId = id;\n        this.styleIDMap.set(stylesheet, newId);\n        this.idStyleMap.set(newId, stylesheet);\n        return newId;\n    }\n    getStyle(id) {\n        return this.idStyleMap.get(id) || null;\n    }\n    reset() {\n        this.styleIDMap = new WeakMap();\n        this.idStyleMap = new Map();\n        this.id = 1;\n    }\n    generateId() {\n        return this.id++;\n    }\n}\nfunction getShadowHost(n) {\n    let shadowHost = null;\n    if (_optionalChain$4([n, 'access', _19 => _19.getRootNode, 'optionalCall', _20 => _20(), 'optionalAccess', _21 => _21.nodeType]) === Node.DOCUMENT_FRAGMENT_NODE &&\n        n.getRootNode().host)\n        shadowHost = n.getRootNode().host;\n    return shadowHost;\n}\nfunction getRootShadowHost(n) {\n    let rootShadowHost = n;\n    let shadowHost;\n    while ((shadowHost = getShadowHost(rootShadowHost)))\n        rootShadowHost = shadowHost;\n    return rootShadowHost;\n}\nfunction shadowHostInDom(n) {\n    const doc = n.ownerDocument;\n    if (!doc)\n        return false;\n    const shadowHost = getRootShadowHost(n);\n    return doc.contains(shadowHost);\n}\nfunction inDom(n) {\n    const doc = n.ownerDocument;\n    if (!doc)\n        return false;\n    return doc.contains(n) || shadowHostInDom(n);\n}\nconst cachedImplementations = {};\nfunction getImplementation(name) {\n    const cached = cachedImplementations[name];\n    if (cached) {\n        return cached;\n    }\n    const document = window.document;\n    let impl = window[name];\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[name]) {\n                impl =\n                    contentWindow[name];\n            }\n            document.head.removeChild(sandbox);\n        }\n        catch (e) {\n        }\n    }\n    return (cachedImplementations[name] = impl.bind(window));\n}\nfunction onRequestAnimationFrame(...rest) {\n    return getImplementation('requestAnimationFrame')(...rest);\n}\nfunction setTimeout$1(...rest) {\n    return getImplementation('setTimeout')(...rest);\n}\nfunction clearTimeout$1(...rest) {\n    return getImplementation('clearTimeout')(...rest);\n}\n\nvar 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 || {});\n\nvar NodeType$1;\n(function (NodeType) {\n    NodeType[NodeType[\"Document\"] = 0] = \"Document\";\n    NodeType[NodeType[\"DocumentType\"] = 1] = \"DocumentType\";\n    NodeType[NodeType[\"Element\"] = 2] = \"Element\";\n    NodeType[NodeType[\"Text\"] = 3] = \"Text\";\n    NodeType[NodeType[\"CDATA\"] = 4] = \"CDATA\";\n    NodeType[NodeType[\"Comment\"] = 5] = \"Comment\";\n})(NodeType$1 || (NodeType$1 = {}));\nvar NodeType$2;\n(function (NodeType) {\n    NodeType[NodeType[\"PLACEHOLDER\"] = 0] = \"PLACEHOLDER\";\n    NodeType[NodeType[\"ELEMENT_NODE\"] = 1] = \"ELEMENT_NODE\";\n    NodeType[NodeType[\"ATTRIBUTE_NODE\"] = 2] = \"ATTRIBUTE_NODE\";\n    NodeType[NodeType[\"TEXT_NODE\"] = 3] = \"TEXT_NODE\";\n    NodeType[NodeType[\"CDATA_SECTION_NODE\"] = 4] = \"CDATA_SECTION_NODE\";\n    NodeType[NodeType[\"ENTITY_REFERENCE_NODE\"] = 5] = \"ENTITY_REFERENCE_NODE\";\n    NodeType[NodeType[\"ENTITY_NODE\"] = 6] = \"ENTITY_NODE\";\n    NodeType[NodeType[\"PROCESSING_INSTRUCTION_NODE\"] = 7] = \"PROCESSING_INSTRUCTION_NODE\";\n    NodeType[NodeType[\"COMMENT_NODE\"] = 8] = \"COMMENT_NODE\";\n    NodeType[NodeType[\"DOCUMENT_NODE\"] = 9] = \"DOCUMENT_NODE\";\n    NodeType[NodeType[\"DOCUMENT_TYPE_NODE\"] = 10] = \"DOCUMENT_TYPE_NODE\";\n    NodeType[NodeType[\"DOCUMENT_FRAGMENT_NODE\"] = 11] = \"DOCUMENT_FRAGMENT_NODE\";\n})(NodeType$2 || (NodeType$2 = {}));\n\nfunction getIFrameContentDocument(iframe) {\n    try {\n        return iframe.contentDocument;\n    }\n    catch (e) {\n    }\n}\nfunction getIFrameContentWindow(iframe) {\n    try {\n        return iframe.contentWindow;\n    }\n    catch (e) {\n    }\n}\n\nfunction _optionalChain$3(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }\nfunction isNodeInLinkedList(n) {\n    return '__ln' in n;\n}\nclass DoubleLinkedList {\n    constructor() {\n        this.length = 0;\n        this.head = null;\n        this.tail = null;\n    }\n    get(position) {\n        if (position >= this.length) {\n            throw new Error('Position outside of list range');\n        }\n        let current = this.head;\n        for (let index = 0; index < position; index++) {\n            current = _optionalChain$3([current, 'optionalAccess', _ => _.next]) || null;\n        }\n        return current;\n    }\n    addNode(n) {\n        const node = {\n            value: n,\n            previous: null,\n            next: null,\n        };\n        n.__ln = node;\n        if (n.previousSibling && isNodeInLinkedList(n.previousSibling)) {\n            const current = n.previousSibling.__ln.next;\n            node.next = current;\n            node.previous = n.previousSibling.__ln;\n            n.previousSibling.__ln.next = node;\n            if (current) {\n                current.previous = node;\n            }\n        }\n        else if (n.nextSibling &&\n            isNodeInLinkedList(n.nextSibling) &&\n            n.nextSibling.__ln.previous) {\n            const current = n.nextSibling.__ln.previous;\n            node.previous = current;\n            node.next = n.nextSibling.__ln;\n            n.nextSibling.__ln.previous = node;\n            if (current) {\n                current.next = node;\n            }\n        }\n        else {\n            if (this.head) {\n                this.head.previous = node;\n            }\n            node.next = this.head;\n            this.head = node;\n        }\n        if (node.next === null) {\n            this.tail = node;\n        }\n        this.length++;\n    }\n    removeNode(n) {\n        const current = n.__ln;\n        if (!this.head) {\n            return;\n        }\n        if (!current.previous) {\n            this.head = current.next;\n            if (this.head) {\n                this.head.previous = null;\n            }\n            else {\n                this.tail = null;\n            }\n        }\n        else {\n            current.previous.next = current.next;\n            if (current.next) {\n                current.next.previous = current.previous;\n            }\n            else {\n                this.tail = current.previous;\n            }\n        }\n        if (n.__ln) {\n            delete n.__ln;\n        }\n        this.length--;\n    }\n}\nconst moveKey = (id, parentId) => `${id}@${parentId}`;\nclass MutationBuffer {\n    constructor() {\n        this.frozen = false;\n        this.locked = false;\n        this.texts = [];\n        this.attributes = [];\n        this.attributeMap = new WeakMap();\n        this.removes = [];\n        this.mapRemoves = [];\n        this.movedMap = {};\n        this.addedSet = new Set();\n        this.movedSet = new Set();\n        this.droppedSet = new Set();\n        this.processMutations = (mutations) => {\n            mutations.forEach(this.processMutation);\n            this.emit();\n        };\n        this.emit = () => {\n            if (this.frozen || this.locked) {\n                return;\n            }\n            const adds = [];\n            const addedIds = new Set();\n            const addList = new DoubleLinkedList();\n            const getNextId = (n) => {\n                let ns = n;\n                let nextId = IGNORED_NODE;\n                while (nextId === IGNORED_NODE) {\n                    ns = ns && ns.nextSibling;\n                    nextId = ns && this.mirror.getId(ns);\n                }\n                return nextId;\n            };\n            const pushAdd = (n) => {\n                if (!n.parentNode || !inDom(n)) {\n                    return;\n                }\n                const parentId = isShadowRoot(n.parentNode)\n                    ? this.mirror.getId(getShadowHost(n))\n                    : this.mirror.getId(n.parentNode);\n                const nextId = getNextId(n);\n                if (parentId === -1 || nextId === -1) {\n                    return addList.addNode(n);\n                }\n                const sn = serializeNodeWithId(n, {\n                    doc: this.doc,\n                    mirror: this.mirror,\n                    blockClass: this.blockClass,\n                    blockSelector: this.blockSelector,\n                    maskAllText: this.maskAllText,\n                    unblockSelector: this.unblockSelector,\n                    maskTextClass: this.maskTextClass,\n                    unmaskTextClass: this.unmaskTextClass,\n                    maskTextSelector: this.maskTextSelector,\n                    unmaskTextSelector: this.unmaskTextSelector,\n                    skipChild: true,\n                    newlyAddedElement: true,\n                    inlineStylesheet: this.inlineStylesheet,\n                    maskInputOptions: this.maskInputOptions,\n                    maskAttributeFn: this.maskAttributeFn,\n                    maskTextFn: this.maskTextFn,\n                    maskInputFn: this.maskInputFn,\n                    slimDOMOptions: this.slimDOMOptions,\n                    dataURLOptions: this.dataURLOptions,\n                    recordCanvas: this.recordCanvas,\n                    inlineImages: this.inlineImages,\n                    onSerialize: (currentN) => {\n                        if (isSerializedIframe(currentN, this.mirror) &&\n                            !isBlocked(currentN, this.blockClass, this.blockSelector, this.unblockSelector, false)) {\n                            this.iframeManager.addIframe(currentN);\n                        }\n                        if (isSerializedStylesheet(currentN, this.mirror)) {\n                            this.stylesheetManager.trackLinkElement(currentN);\n                        }\n                        if (hasShadowRoot(n)) {\n                            this.shadowDomManager.addShadowRoot(n.shadowRoot, this.doc);\n                        }\n                    },\n                    onIframeLoad: (iframe, childSn) => {\n                        if (isBlocked(iframe, this.blockClass, this.blockSelector, this.unblockSelector, false)) {\n                            return;\n                        }\n                        this.iframeManager.attachIframe(iframe, childSn);\n                        if (iframe.contentWindow) {\n                            this.canvasManager.addWindow(iframe.contentWindow);\n                        }\n                        this.shadowDomManager.observeAttachShadow(iframe);\n                    },\n                    onStylesheetLoad: (link, childSn) => {\n                        this.stylesheetManager.attachLinkElement(link, childSn);\n                    },\n                });\n                if (sn) {\n                    adds.push({\n                        parentId,\n                        nextId,\n                        node: sn,\n                    });\n                    addedIds.add(sn.id);\n                }\n            };\n            while (this.mapRemoves.length) {\n                this.mirror.removeNodeFromMap(this.mapRemoves.shift());\n            }\n            for (const n of this.movedSet) {\n                if (isParentRemoved(this.removes, n, this.mirror) &&\n                    !this.movedSet.has(n.parentNode)) {\n                    continue;\n                }\n                pushAdd(n);\n            }\n            for (const n of this.addedSet) {\n                if (!isAncestorInSet(this.droppedSet, n) &&\n                    !isParentRemoved(this.removes, n, this.mirror)) {\n                    pushAdd(n);\n                }\n                else if (isAncestorInSet(this.movedSet, n)) {\n                    pushAdd(n);\n                }\n                else {\n                    this.droppedSet.add(n);\n                }\n            }\n            let candidate = null;\n            while (addList.length) {\n                let node = null;\n                if (candidate) {\n                    const parentId = this.mirror.getId(candidate.value.parentNode);\n                    const nextId = getNextId(candidate.value);\n                    if (parentId !== -1 && nextId !== -1) {\n                        node = candidate;\n                    }\n                }\n                if (!node) {\n                    let tailNode = addList.tail;\n                    while (tailNode) {\n                        const _node = tailNode;\n                        tailNode = tailNode.previous;\n                        if (_node) {\n                            const parentId = this.mirror.getId(_node.value.parentNode);\n                            const nextId = getNextId(_node.value);\n                            if (nextId === -1)\n                                continue;\n                            else if (parentId !== -1) {\n                                node = _node;\n                                break;\n                            }\n                            else {\n                                const unhandledNode = _node.value;\n                                if (unhandledNode.parentNode &&\n                                    unhandledNode.parentNode.nodeType ===\n                                        Node.DOCUMENT_FRAGMENT_NODE) {\n                                    const shadowHost = unhandledNode.parentNode\n                                        .host;\n                                    const parentId = this.mirror.getId(shadowHost);\n                                    if (parentId !== -1) {\n                                        node = _node;\n                                        break;\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n                if (!node) {\n                    while (addList.head) {\n                        addList.removeNode(addList.head.value);\n                    }\n                    break;\n                }\n                candidate = node.previous;\n                addList.removeNode(node.value);\n                pushAdd(node.value);\n            }\n            const payload = {\n                texts: this.texts\n                    .map((text) => ({\n                    id: this.mirror.getId(text.node),\n                    value: text.value,\n                }))\n                    .filter((text) => !addedIds.has(text.id))\n                    .filter((text) => this.mirror.has(text.id)),\n                attributes: this.attributes\n                    .map((attribute) => {\n                    const { attributes } = attribute;\n                    if (typeof attributes.style === 'string') {\n                        const diffAsStr = JSON.stringify(attribute.styleDiff);\n                        const unchangedAsStr = JSON.stringify(attribute._unchangedStyles);\n                        if (diffAsStr.length < attributes.style.length) {\n                            if ((diffAsStr + unchangedAsStr).split('var(').length ===\n                                attributes.style.split('var(').length) {\n                                attributes.style = attribute.styleDiff;\n                            }\n                        }\n                    }\n                    return {\n                        id: this.mirror.getId(attribute.node),\n                        attributes: attributes,\n                    };\n                })\n                    .filter((attribute) => !addedIds.has(attribute.id))\n                    .filter((attribute) => this.mirror.has(attribute.id)),\n                removes: this.removes,\n                adds,\n            };\n            if (!payload.texts.length &&\n                !payload.attributes.length &&\n                !payload.removes.length &&\n                !payload.adds.length) {\n                return;\n            }\n            this.texts = [];\n            this.attributes = [];\n            this.attributeMap = new WeakMap();\n            this.removes = [];\n            this.addedSet = new Set();\n            this.movedSet = new Set();\n            this.droppedSet = new Set();\n            this.movedMap = {};\n            this.mutationCb(payload);\n        };\n        this.processMutation = (m) => {\n            if (isIgnored(m.target, this.mirror)) {\n                return;\n            }\n            switch (m.type) {\n                case 'characterData': {\n                    const value = m.target.textContent;\n                    if (!isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, false) &&\n                        value !== m.oldValue) {\n                        this.texts.push({\n                            value: needMaskingText(m.target, this.maskTextClass, this.maskTextSelector, this.unmaskTextClass, this.unmaskTextSelector, this.maskAllText) && value\n                                ? this.maskTextFn\n                                    ? this.maskTextFn(value, closestElementOfNode(m.target))\n                                    : value.replace(/[\\S]/g, '*')\n                                : value,\n                            node: m.target,\n                        });\n                    }\n                    break;\n                }\n                case 'attributes': {\n                    const target = m.target;\n                    let attributeName = m.attributeName;\n                    let value = m.target.getAttribute(attributeName);\n                    if (attributeName === 'value') {\n                        const type = getInputType(target);\n                        const tagName = target.tagName;\n                        value = getInputValue(target, tagName, type);\n                        const isInputMasked = shouldMaskInput({\n                            maskInputOptions: this.maskInputOptions,\n                            tagName,\n                            type,\n                        });\n                        const forceMask = needMaskingText(m.target, this.maskTextClass, this.maskTextSelector, this.unmaskTextClass, this.unmaskTextSelector, isInputMasked);\n                        value = maskInputValue({\n                            isMasked: forceMask,\n                            element: target,\n                            value,\n                            maskInputFn: this.maskInputFn,\n                        });\n                    }\n                    if (isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, false) ||\n                        value === m.oldValue) {\n                        return;\n                    }\n                    let item = this.attributeMap.get(m.target);\n                    if (target.tagName === 'IFRAME' &&\n                        attributeName === 'src' &&\n                        !this.keepIframeSrcFn(value)) {\n                        const iframeDoc = getIFrameContentDocument(target);\n                        if (!iframeDoc) {\n                            attributeName = 'rr_src';\n                        }\n                        else {\n                            return;\n                        }\n                    }\n                    if (!item) {\n                        item = {\n                            node: m.target,\n                            attributes: {},\n                            styleDiff: {},\n                            _unchangedStyles: {},\n                        };\n                        this.attributes.push(item);\n                        this.attributeMap.set(m.target, item);\n                    }\n                    if (attributeName === 'type' &&\n                        target.tagName === 'INPUT' &&\n                        (m.oldValue || '').toLowerCase() === 'password') {\n                        target.setAttribute('data-rr-is-password', 'true');\n                    }\n                    if (!ignoreAttribute(target.tagName, attributeName)) {\n                        item.attributes[attributeName] = transformAttribute(this.doc, toLowerCase(target.tagName), toLowerCase(attributeName), value, target, this.maskAttributeFn);\n                        if (attributeName === 'style') {\n                            if (!this.unattachedDoc) {\n                                try {\n                                    this.unattachedDoc =\n                                        document.implementation.createHTMLDocument();\n                                }\n                                catch (e) {\n                                    this.unattachedDoc = this.doc;\n                                }\n                            }\n                            const old = this.unattachedDoc.createElement('span');\n                            if (m.oldValue) {\n                                old.setAttribute('style', m.oldValue);\n                            }\n                            for (const pname of Array.from(target.style)) {\n                                const newValue = target.style.getPropertyValue(pname);\n                                const newPriority = target.style.getPropertyPriority(pname);\n                                if (newValue !== old.style.getPropertyValue(pname) ||\n                                    newPriority !== old.style.getPropertyPriority(pname)) {\n                                    if (newPriority === '') {\n                                        item.styleDiff[pname] = newValue;\n                                    }\n                                    else {\n                                        item.styleDiff[pname] = [newValue, newPriority];\n                                    }\n                                }\n                                else {\n                                    item._unchangedStyles[pname] = [newValue, newPriority];\n                                }\n                            }\n                            for (const pname of Array.from(old.style)) {\n                                if (target.style.getPropertyValue(pname) === '') {\n                                    item.styleDiff[pname] = false;\n                                }\n                            }\n                        }\n                    }\n                    break;\n                }\n                case 'childList': {\n                    if (isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, true)) {\n                        return;\n                    }\n                    m.addedNodes.forEach((n) => this.genAdds(n, m.target));\n                    m.removedNodes.forEach((n) => {\n                        const nodeId = this.mirror.getId(n);\n                        const parentId = isShadowRoot(m.target)\n                            ? this.mirror.getId(m.target.host)\n                            : this.mirror.getId(m.target);\n                        if (isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, false) ||\n                            isIgnored(n, this.mirror) ||\n                            !isSerialized(n, this.mirror)) {\n                            return;\n                        }\n                        if (this.addedSet.has(n)) {\n                            deepDelete(this.addedSet, n);\n                            this.droppedSet.add(n);\n                        }\n                        else if (this.addedSet.has(m.target) && nodeId === -1) ;\n                        else if (isAncestorRemoved(m.target, this.mirror)) ;\n                        else if (this.movedSet.has(n) &&\n                            this.movedMap[moveKey(nodeId, parentId)]) {\n                            deepDelete(this.movedSet, n);\n                        }\n                        else {\n                            this.removes.push({\n                                parentId,\n                                id: nodeId,\n                                isShadow: isShadowRoot(m.target) && isNativeShadowDom(m.target)\n                                    ? true\n                                    : undefined,\n                            });\n                        }\n                        this.mapRemoves.push(n);\n                    });\n                    break;\n                }\n            }\n        };\n        this.genAdds = (n, target) => {\n            if (this.processedNodeManager.inOtherBuffer(n, this))\n                return;\n            if (this.addedSet.has(n) || this.movedSet.has(n))\n                return;\n            if (this.mirror.hasNode(n)) {\n                if (isIgnored(n, this.mirror)) {\n                    return;\n                }\n                this.movedSet.add(n);\n                let targetId = null;\n                if (target && this.mirror.hasNode(target)) {\n                    targetId = this.mirror.getId(target);\n                }\n                if (targetId && targetId !== -1) {\n                    this.movedMap[moveKey(this.mirror.getId(n), targetId)] = true;\n                }\n            }\n            else {\n                this.addedSet.add(n);\n                this.droppedSet.delete(n);\n            }\n            if (!isBlocked(n, this.blockClass, this.blockSelector, this.unblockSelector, false)) {\n                n.childNodes.forEach((childN) => this.genAdds(childN));\n                if (hasShadowRoot(n)) {\n                    n.shadowRoot.childNodes.forEach((childN) => {\n                        this.processedNodeManager.add(childN, this);\n                        this.genAdds(childN, n);\n                    });\n                }\n            }\n        };\n    }\n    init(options) {\n        [\n            'mutationCb',\n            'blockClass',\n            'blockSelector',\n            'unblockSelector',\n            'maskAllText',\n            'maskTextClass',\n            'unmaskTextClass',\n            'maskTextSelector',\n            'unmaskTextSelector',\n            'inlineStylesheet',\n            'maskInputOptions',\n            'maskAttributeFn',\n            'maskTextFn',\n            'maskInputFn',\n            'keepIframeSrcFn',\n            'recordCanvas',\n            'inlineImages',\n            'slimDOMOptions',\n            'dataURLOptions',\n            'doc',\n            'mirror',\n            'iframeManager',\n            'stylesheetManager',\n            'shadowDomManager',\n            'canvasManager',\n            'processedNodeManager',\n        ].forEach((key) => {\n            this[key] = options[key];\n        });\n    }\n    freeze() {\n        this.frozen = true;\n        this.canvasManager.freeze();\n    }\n    unfreeze() {\n        this.frozen = false;\n        this.canvasManager.unfreeze();\n        this.emit();\n    }\n    isFrozen() {\n        return this.frozen;\n    }\n    lock() {\n        this.locked = true;\n        this.canvasManager.lock();\n    }\n    unlock() {\n        this.locked = false;\n        this.canvasManager.unlock();\n        this.emit();\n    }\n    reset() {\n        this.shadowDomManager.reset();\n        this.canvasManager.reset();\n    }\n}\nfunction deepDelete(addsSet, n) {\n    addsSet.delete(n);\n    n.childNodes.forEach((childN) => deepDelete(addsSet, childN));\n}\nfunction isParentRemoved(removes, n, mirror) {\n    if (removes.length === 0)\n        return false;\n    return _isParentRemoved(removes, n, mirror);\n}\nfunction _isParentRemoved(removes, n, mirror) {\n    let node = n.parentNode;\n    while (node) {\n        const parentId = mirror.getId(node);\n        if (removes.some((r) => r.id === parentId)) {\n            return true;\n        }\n        node = node.parentNode;\n    }\n    return false;\n}\nfunction isAncestorInSet(set, n) {\n    if (set.size === 0)\n        return false;\n    return _isAncestorInSet(set, n);\n}\nfunction _isAncestorInSet(set, n) {\n    const { parentNode } = n;\n    if (!parentNode) {\n        return false;\n    }\n    if (set.has(parentNode)) {\n        return true;\n    }\n    return _isAncestorInSet(set, parentNode);\n}\n\nlet errorHandler;\nfunction registerErrorHandler(handler) {\n    errorHandler = handler;\n}\nfunction unregisterErrorHandler() {\n    errorHandler = undefined;\n}\nconst callbackWrapper = (cb) => {\n    if (!errorHandler) {\n        return cb;\n    }\n    const rrwebWrapped = ((...rest) => {\n        try {\n            return cb(...rest);\n        }\n        catch (error) {\n            if (errorHandler && errorHandler(error) === true) {\n                return () => {\n                };\n            }\n            throw error;\n        }\n    });\n    return rrwebWrapped;\n};\n\nfunction _optionalChain$2(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }\nconst mutationBuffers = [];\nfunction getEventTarget(event) {\n    try {\n        if ('composedPath' in event) {\n            const path = event.composedPath();\n            if (path.length) {\n                return path[0];\n            }\n        }\n        else if ('path' in event && event.path.length) {\n            return event.path[0];\n        }\n    }\n    catch (e2) {\n    }\n    return event && event.target;\n}\nfunction initMutationObserver(options, rootEl) {\n    const mutationBuffer = new MutationBuffer();\n    mutationBuffers.push(mutationBuffer);\n    mutationBuffer.init(options);\n    let mutationObserverCtor = window.MutationObserver ||\n        window.__rrMutationObserver;\n    const angularZoneSymbol = _optionalChain$2([window, 'optionalAccess', _ => _.Zone, 'optionalAccess', _2 => _2.__symbol__, 'optionalCall', _3 => _3('MutationObserver')]);\n    if (angularZoneSymbol &&\n        window[angularZoneSymbol]) {\n        mutationObserverCtor = window[angularZoneSymbol];\n    }\n    const observer = new mutationObserverCtor(callbackWrapper((mutations) => {\n        if (options.onMutation && options.onMutation(mutations) === false) {\n            return;\n        }\n        mutationBuffer.processMutations.bind(mutationBuffer)(mutations);\n    }));\n    observer.observe(rootEl, {\n        attributes: true,\n        attributeOldValue: true,\n        characterData: true,\n        characterDataOldValue: true,\n        childList: true,\n        subtree: true,\n    });\n    return observer;\n}\nfunction initMoveObserver({ mousemoveCb, sampling, doc, mirror, }) {\n    if (sampling.mousemove === false) {\n        return () => {\n        };\n    }\n    const threshold = typeof sampling.mousemove === 'number' ? sampling.mousemove : 50;\n    const callbackThreshold = typeof sampling.mousemoveCallback === 'number'\n        ? sampling.mousemoveCallback\n        : 500;\n    let positions = [];\n    let timeBaseline;\n    const wrappedCb = throttle$1(callbackWrapper((source) => {\n        const totalOffset = Date.now() - timeBaseline;\n        mousemoveCb(positions.map((p) => {\n            p.timeOffset -= totalOffset;\n            return p;\n        }), source);\n        positions = [];\n        timeBaseline = null;\n    }), callbackThreshold);\n    const updatePosition = callbackWrapper(throttle$1(callbackWrapper((evt) => {\n        const target = getEventTarget(evt);\n        const { clientX, clientY } = legacy_isTouchEvent(evt)\n            ? evt.changedTouches[0]\n            : evt;\n        if (!timeBaseline) {\n            timeBaseline = nowTimestamp();\n        }\n        positions.push({\n            x: clientX,\n            y: clientY,\n            id: mirror.getId(target),\n            timeOffset: nowTimestamp() - timeBaseline,\n        });\n        wrappedCb(typeof DragEvent !== 'undefined' && evt instanceof DragEvent\n            ? IncrementalSource.Drag\n            : evt instanceof MouseEvent\n                ? IncrementalSource.MouseMove\n                : IncrementalSource.TouchMove);\n    }), threshold, {\n        trailing: false,\n    }));\n    const handlers = [\n        on('mousemove', updatePosition, doc),\n        on('touchmove', updatePosition, doc),\n        on('drag', updatePosition, doc),\n    ];\n    return callbackWrapper(() => {\n        handlers.forEach((h) => h());\n    });\n}\nfunction initMouseInteractionObserver({ mouseInteractionCb, doc, mirror, blockClass, blockSelector, unblockSelector, sampling, }) {\n    if (sampling.mouseInteraction === false) {\n        return () => {\n        };\n    }\n    const disableMap = sampling.mouseInteraction === true ||\n        sampling.mouseInteraction === undefined\n        ? {}\n        : sampling.mouseInteraction;\n    const handlers = [];\n    let currentPointerType = null;\n    const getHandler = (eventKey) => {\n        return (event) => {\n            const target = getEventTarget(event);\n            if (isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\n                return;\n            }\n            let pointerType = null;\n            let thisEventKey = eventKey;\n            if ('pointerType' in event) {\n                switch (event.pointerType) {\n                    case 'mouse':\n                        pointerType = PointerTypes.Mouse;\n                        break;\n                    case 'touch':\n                        pointerType = PointerTypes.Touch;\n                        break;\n                    case 'pen':\n                        pointerType = PointerTypes.Pen;\n                        break;\n                }\n                if (pointerType === PointerTypes.Touch) {\n                    if (MouseInteractions[eventKey] === MouseInteractions.MouseDown) {\n                        thisEventKey = 'TouchStart';\n                    }\n                    else if (MouseInteractions[eventKey] === MouseInteractions.MouseUp) {\n                        thisEventKey = 'TouchEnd';\n                    }\n                }\n                else if (pointerType === PointerTypes.Pen) ;\n            }\n            else if (legacy_isTouchEvent(event)) {\n                pointerType = PointerTypes.Touch;\n            }\n            if (pointerType !== null) {\n                currentPointerType = pointerType;\n                if ((thisEventKey.startsWith('Touch') &&\n                    pointerType === PointerTypes.Touch) ||\n                    (thisEventKey.startsWith('Mouse') &&\n                        pointerType === PointerTypes.Mouse)) {\n                    pointerType = null;\n                }\n            }\n            else if (MouseInteractions[eventKey] === MouseInteractions.Click) {\n                pointerType = currentPointerType;\n                currentPointerType = null;\n            }\n            const e = legacy_isTouchEvent(event) ? event.changedTouches[0] : event;\n            if (!e) {\n                return;\n            }\n            const id = mirror.getId(target);\n            const { clientX, clientY } = e;\n            callbackWrapper(mouseInteractionCb)({\n                type: MouseInteractions[thisEventKey],\n                id,\n                x: clientX,\n                y: clientY,\n                ...(pointerType !== null && { pointerType }),\n            });\n        };\n    };\n    Object.keys(MouseInteractions)\n        .filter((key) => Number.isNaN(Number(key)) &&\n        !key.endsWith('_Departed') &&\n        disableMap[key] !== false)\n        .forEach((eventKey) => {\n        let eventName = toLowerCase(eventKey);\n        const handler = getHandler(eventKey);\n        if (window.PointerEvent) {\n            switch (MouseInteractions[eventKey]) {\n                case MouseInteractions.MouseDown:\n                case MouseInteractions.MouseUp:\n                    eventName = eventName.replace('mouse', 'pointer');\n                    break;\n                case MouseInteractions.TouchStart:\n                case MouseInteractions.TouchEnd:\n                    return;\n            }\n        }\n        handlers.push(on(eventName, handler, doc));\n    });\n    return callbackWrapper(() => {\n        handlers.forEach((h) => h());\n    });\n}\nfunction initScrollObserver({ scrollCb, doc, mirror, blockClass, blockSelector, unblockSelector, sampling, }) {\n    const updatePosition = callbackWrapper(throttle$1(callbackWrapper((evt) => {\n        const target = getEventTarget(evt);\n        if (!target ||\n            isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\n            return;\n        }\n        const id = mirror.getId(target);\n        if (target === doc && doc.defaultView) {\n            const scrollLeftTop = getWindowScroll(doc.defaultView);\n            scrollCb({\n                id,\n                x: scrollLeftTop.left,\n                y: scrollLeftTop.top,\n            });\n        }\n        else {\n            scrollCb({\n                id,\n                x: target.scrollLeft,\n                y: target.scrollTop,\n            });\n        }\n    }), sampling.scroll || 100));\n    return on('scroll', updatePosition, doc);\n}\nfunction initViewportResizeObserver({ viewportResizeCb }, { win }) {\n    let lastH = -1;\n    let lastW = -1;\n    const updateDimension = callbackWrapper(throttle$1(callbackWrapper(() => {\n        const height = getWindowHeight();\n        const width = getWindowWidth();\n        if (lastH !== height || lastW !== width) {\n            viewportResizeCb({\n                width: Number(width),\n                height: Number(height),\n            });\n            lastH = height;\n            lastW = width;\n        }\n    }), 200));\n    return on('resize', updateDimension, win);\n}\nconst INPUT_TAGS = ['INPUT', 'TEXTAREA', 'SELECT'];\nconst lastInputValueMap = new WeakMap();\nfunction initInputObserver({ inputCb, doc, mirror, blockClass, blockSelector, unblockSelector, ignoreClass, ignoreSelector, maskInputOptions, maskInputFn, sampling, userTriggeredOnInput, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, }) {\n    function eventHandler(event) {\n        let target = getEventTarget(event);\n        const userTriggered = event.isTrusted;\n        const tagName = target && toUpperCase(target.tagName);\n        if (tagName === 'OPTION')\n            target = target.parentElement;\n        if (!target ||\n            !tagName ||\n            INPUT_TAGS.indexOf(tagName) < 0 ||\n            isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\n            return;\n        }\n        const el = target;\n        if (el.classList.contains(ignoreClass) ||\n            (ignoreSelector && el.matches(ignoreSelector))) {\n            return;\n        }\n        const type = getInputType(target);\n        let text = getInputValue(el, tagName, type);\n        let isChecked = false;\n        const isInputMasked = shouldMaskInput({\n            maskInputOptions,\n            tagName,\n            type,\n        });\n        const forceMask = needMaskingText(target, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, isInputMasked);\n        if (type === 'radio' || type === 'checkbox') {\n            isChecked = target.checked;\n        }\n        text = maskInputValue({\n            isMasked: forceMask,\n            element: target,\n            value: text,\n            maskInputFn,\n        });\n        cbWithDedup(target, userTriggeredOnInput\n            ? { text, isChecked, userTriggered }\n            : { text, isChecked });\n        const name = target.name;\n        if (type === 'radio' && name && isChecked) {\n            doc\n                .querySelectorAll(`input[type=\"radio\"][name=\"${name}\"]`)\n                .forEach((el) => {\n                if (el !== target) {\n                    const text = maskInputValue({\n                        isMasked: forceMask,\n                        element: el,\n                        value: getInputValue(el, tagName, type),\n                        maskInputFn,\n                    });\n                    cbWithDedup(el, userTriggeredOnInput\n                        ? { text, isChecked: !isChecked, userTriggered: false }\n                        : { text, isChecked: !isChecked });\n                }\n            });\n        }\n    }\n    function cbWithDedup(target, v) {\n        const lastInputValue = lastInputValueMap.get(target);\n        if (!lastInputValue ||\n            lastInputValue.text !== v.text ||\n            lastInputValue.isChecked !== v.isChecked) {\n            lastInputValueMap.set(target, v);\n            const id = mirror.getId(target);\n            callbackWrapper(inputCb)({\n                ...v,\n                id,\n            });\n        }\n    }\n    const events = sampling.input === 'last' ? ['change'] : ['input', 'change'];\n    const handlers = events.map((eventName) => on(eventName, callbackWrapper(eventHandler), doc));\n    const currentWindow = doc.defaultView;\n    if (!currentWindow) {\n        return () => {\n            handlers.forEach((h) => h());\n        };\n    }\n    const propertyDescriptor = currentWindow.Object.getOwnPropertyDescriptor(currentWindow.HTMLInputElement.prototype, 'value');\n    const hookProperties = [\n        [currentWindow.HTMLInputElement.prototype, 'value'],\n        [currentWindow.HTMLInputElement.prototype, 'checked'],\n        [currentWindow.HTMLSelectElement.prototype, 'value'],\n        [currentWindow.HTMLTextAreaElement.prototype, 'value'],\n        [currentWindow.HTMLSelectElement.prototype, 'selectedIndex'],\n        [currentWindow.HTMLOptionElement.prototype, 'selected'],\n    ];\n    if (propertyDescriptor && propertyDescriptor.set) {\n        handlers.push(...hookProperties.map((p) => hookSetter(p[0], p[1], {\n            set() {\n                callbackWrapper(eventHandler)({\n                    target: this,\n                    isTrusted: false,\n                });\n            },\n        }, false, currentWindow)));\n    }\n    return callbackWrapper(() => {\n        handlers.forEach((h) => h());\n    });\n}\nfunction getNestedCSSRulePositions(rule) {\n    const positions = [];\n    function recurse(childRule, pos) {\n        if ((hasNestedCSSRule('CSSGroupingRule') &&\n            childRule.parentRule instanceof CSSGroupingRule) ||\n            (hasNestedCSSRule('CSSMediaRule') &&\n                childRule.parentRule instanceof CSSMediaRule) ||\n            (hasNestedCSSRule('CSSSupportsRule') &&\n                childRule.parentRule instanceof CSSSupportsRule) ||\n            (hasNestedCSSRule('CSSConditionRule') &&\n                childRule.parentRule instanceof CSSConditionRule)) {\n            const rules = Array.from(childRule.parentRule.cssRules);\n            const index = rules.indexOf(childRule);\n            pos.unshift(index);\n        }\n        else if (childRule.parentStyleSheet) {\n            const rules = Array.from(childRule.parentStyleSheet.cssRules);\n            const index = rules.indexOf(childRule);\n            pos.unshift(index);\n        }\n        return pos;\n    }\n    return recurse(rule, positions);\n}\nfunction getIdAndStyleId(sheet, mirror, styleMirror) {\n    let id, styleId;\n    if (!sheet)\n        return {};\n    if (sheet.ownerNode)\n        id = mirror.getId(sheet.ownerNode);\n    else\n        styleId = styleMirror.getId(sheet);\n    return {\n        styleId,\n        id,\n    };\n}\nfunction initStyleSheetObserver({ styleSheetRuleCb, mirror, stylesheetManager }, { win }) {\n    if (!win.CSSStyleSheet || !win.CSSStyleSheet.prototype) {\n        return () => {\n        };\n    }\n    const insertRule = win.CSSStyleSheet.prototype.insertRule;\n    win.CSSStyleSheet.prototype.insertRule = new Proxy(insertRule, {\n        apply: callbackWrapper((target, thisArg, argumentsList) => {\n            const [rule, index] = argumentsList;\n            const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\n            if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                styleSheetRuleCb({\n                    id,\n                    styleId,\n                    adds: [{ rule, index }],\n                });\n            }\n            return target.apply(thisArg, argumentsList);\n        }),\n    });\n    const deleteRule = win.CSSStyleSheet.prototype.deleteRule;\n    win.CSSStyleSheet.prototype.deleteRule = new Proxy(deleteRule, {\n        apply: callbackWrapper((target, thisArg, argumentsList) => {\n            const [index] = argumentsList;\n            const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\n            if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                styleSheetRuleCb({\n                    id,\n                    styleId,\n                    removes: [{ index }],\n                });\n            }\n            return target.apply(thisArg, argumentsList);\n        }),\n    });\n    let replace;\n    if (win.CSSStyleSheet.prototype.replace) {\n        replace = win.CSSStyleSheet.prototype.replace;\n        win.CSSStyleSheet.prototype.replace = new Proxy(replace, {\n            apply: callbackWrapper((target, thisArg, argumentsList) => {\n                const [text] = argumentsList;\n                const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\n                if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                    styleSheetRuleCb({\n                        id,\n                        styleId,\n                        replace: text,\n                    });\n                }\n                return target.apply(thisArg, argumentsList);\n            }),\n        });\n    }\n    let replaceSync;\n    if (win.CSSStyleSheet.prototype.replaceSync) {\n        replaceSync = win.CSSStyleSheet.prototype.replaceSync;\n        win.CSSStyleSheet.prototype.replaceSync = new Proxy(replaceSync, {\n            apply: callbackWrapper((target, thisArg, argumentsList) => {\n                const [text] = argumentsList;\n                const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\n                if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                    styleSheetRuleCb({\n                        id,\n                        styleId,\n                        replaceSync: text,\n                    });\n                }\n                return target.apply(thisArg, argumentsList);\n            }),\n        });\n    }\n    const supportedNestedCSSRuleTypes = {};\n    if (canMonkeyPatchNestedCSSRule('CSSGroupingRule')) {\n        supportedNestedCSSRuleTypes.CSSGroupingRule = win.CSSGroupingRule;\n    }\n    else {\n        if (canMonkeyPatchNestedCSSRule('CSSMediaRule')) {\n            supportedNestedCSSRuleTypes.CSSMediaRule = win.CSSMediaRule;\n        }\n        if (canMonkeyPatchNestedCSSRule('CSSConditionRule')) {\n            supportedNestedCSSRuleTypes.CSSConditionRule = win.CSSConditionRule;\n        }\n        if (canMonkeyPatchNestedCSSRule('CSSSupportsRule')) {\n            supportedNestedCSSRuleTypes.CSSSupportsRule = win.CSSSupportsRule;\n        }\n    }\n    const unmodifiedFunctions = {};\n    Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {\n        unmodifiedFunctions[typeKey] = {\n            insertRule: type.prototype.insertRule,\n            deleteRule: type.prototype.deleteRule,\n        };\n        type.prototype.insertRule = new Proxy(unmodifiedFunctions[typeKey].insertRule, {\n            apply: callbackWrapper((target, thisArg, argumentsList) => {\n                const [rule, index] = argumentsList;\n                const { id, styleId } = getIdAndStyleId(thisArg.parentStyleSheet, mirror, stylesheetManager.styleMirror);\n                if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                    styleSheetRuleCb({\n                        id,\n                        styleId,\n                        adds: [\n                            {\n                                rule,\n                                index: [\n                                    ...getNestedCSSRulePositions(thisArg),\n                                    index || 0,\n                                ],\n                            },\n                        ],\n                    });\n                }\n                return target.apply(thisArg, argumentsList);\n            }),\n        });\n        type.prototype.deleteRule = new Proxy(unmodifiedFunctions[typeKey].deleteRule, {\n            apply: callbackWrapper((target, thisArg, argumentsList) => {\n                const [index] = argumentsList;\n                const { id, styleId } = getIdAndStyleId(thisArg.parentStyleSheet, mirror, stylesheetManager.styleMirror);\n                if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                    styleSheetRuleCb({\n                        id,\n                        styleId,\n                        removes: [\n                            { index: [...getNestedCSSRulePositions(thisArg), index] },\n                        ],\n                    });\n                }\n                return target.apply(thisArg, argumentsList);\n            }),\n        });\n    });\n    return callbackWrapper(() => {\n        win.CSSStyleSheet.prototype.insertRule = insertRule;\n        win.CSSStyleSheet.prototype.deleteRule = deleteRule;\n        replace && (win.CSSStyleSheet.prototype.replace = replace);\n        replaceSync && (win.CSSStyleSheet.prototype.replaceSync = replaceSync);\n        Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {\n            type.prototype.insertRule = unmodifiedFunctions[typeKey].insertRule;\n            type.prototype.deleteRule = unmodifiedFunctions[typeKey].deleteRule;\n        });\n    });\n}\nfunction initAdoptedStyleSheetObserver({ mirror, stylesheetManager, }, host) {\n    let hostId = null;\n    if (host.nodeName === '#document')\n        hostId = mirror.getId(host);\n    else\n        hostId = mirror.getId(host.host);\n    const patchTarget = host.nodeName === '#document'\n        ? _optionalChain$2([host, 'access', _4 => _4.defaultView, 'optionalAccess', _5 => _5.Document])\n        : _optionalChain$2([host, 'access', _6 => _6.ownerDocument, 'optionalAccess', _7 => _7.defaultView, 'optionalAccess', _8 => _8.ShadowRoot]);\n    const originalPropertyDescriptor = _optionalChain$2([patchTarget, 'optionalAccess', _9 => _9.prototype])\n        ? Object.getOwnPropertyDescriptor(_optionalChain$2([patchTarget, 'optionalAccess', _10 => _10.prototype]), 'adoptedStyleSheets')\n        : undefined;\n    if (hostId === null ||\n        hostId === -1 ||\n        !patchTarget ||\n        !originalPropertyDescriptor)\n        return () => {\n        };\n    Object.defineProperty(host, 'adoptedStyleSheets', {\n        configurable: originalPropertyDescriptor.configurable,\n        enumerable: originalPropertyDescriptor.enumerable,\n        get() {\n            return _optionalChain$2([originalPropertyDescriptor, 'access', _11 => _11.get, 'optionalAccess', _12 => _12.call, 'call', _13 => _13(this)]);\n        },\n        set(sheets) {\n            const result = _optionalChain$2([originalPropertyDescriptor, 'access', _14 => _14.set, 'optionalAccess', _15 => _15.call, 'call', _16 => _16(this, sheets)]);\n            if (hostId !== null && hostId !== -1) {\n                try {\n                    stylesheetManager.adoptStyleSheets(sheets, hostId);\n                }\n                catch (e) {\n                }\n            }\n            return result;\n        },\n    });\n    return callbackWrapper(() => {\n        Object.defineProperty(host, 'adoptedStyleSheets', {\n            configurable: originalPropertyDescriptor.configurable,\n            enumerable: originalPropertyDescriptor.enumerable,\n            get: originalPropertyDescriptor.get,\n            set: originalPropertyDescriptor.set,\n        });\n    });\n}\nfunction initStyleDeclarationObserver({ styleDeclarationCb, mirror, ignoreCSSAttributes, stylesheetManager, }, { win }) {\n    const setProperty = win.CSSStyleDeclaration.prototype.setProperty;\n    win.CSSStyleDeclaration.prototype.setProperty = new Proxy(setProperty, {\n        apply: callbackWrapper((target, thisArg, argumentsList) => {\n            const [property, value, priority] = argumentsList;\n            if (ignoreCSSAttributes.has(property)) {\n                return setProperty.apply(thisArg, [property, value, priority]);\n            }\n            const { id, styleId } = getIdAndStyleId(_optionalChain$2([thisArg, 'access', _17 => _17.parentRule, 'optionalAccess', _18 => _18.parentStyleSheet]), mirror, stylesheetManager.styleMirror);\n            if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                styleDeclarationCb({\n                    id,\n                    styleId,\n                    set: {\n                        property,\n                        value,\n                        priority,\n                    },\n                    index: getNestedCSSRulePositions(thisArg.parentRule),\n                });\n            }\n            return target.apply(thisArg, argumentsList);\n        }),\n    });\n    const removeProperty = win.CSSStyleDeclaration.prototype.removeProperty;\n    win.CSSStyleDeclaration.prototype.removeProperty = new Proxy(removeProperty, {\n        apply: callbackWrapper((target, thisArg, argumentsList) => {\n            const [property] = argumentsList;\n            if (ignoreCSSAttributes.has(property)) {\n                return removeProperty.apply(thisArg, [property]);\n            }\n            const { id, styleId } = getIdAndStyleId(_optionalChain$2([thisArg, 'access', _19 => _19.parentRule, 'optionalAccess', _20 => _20.parentStyleSheet]), mirror, stylesheetManager.styleMirror);\n            if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                styleDeclarationCb({\n                    id,\n                    styleId,\n                    remove: {\n                        property,\n                    },\n                    index: getNestedCSSRulePositions(thisArg.parentRule),\n                });\n            }\n            return target.apply(thisArg, argumentsList);\n        }),\n    });\n    return callbackWrapper(() => {\n        win.CSSStyleDeclaration.prototype.setProperty = setProperty;\n        win.CSSStyleDeclaration.prototype.removeProperty = removeProperty;\n    });\n}\nfunction initMediaInteractionObserver({ mediaInteractionCb, blockClass, blockSelector, unblockSelector, mirror, sampling, doc, }) {\n    const handler = callbackWrapper((type) => throttle$1(callbackWrapper((event) => {\n        const target = getEventTarget(event);\n        if (!target ||\n            isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\n            return;\n        }\n        const { currentTime, volume, muted, playbackRate } = target;\n        mediaInteractionCb({\n            type,\n            id: mirror.getId(target),\n            currentTime,\n            volume,\n            muted,\n            playbackRate,\n        });\n    }), sampling.media || 500));\n    const handlers = [\n        on('play', handler(0), doc),\n        on('pause', handler(1), doc),\n        on('seeked', handler(2), doc),\n        on('volumechange', handler(3), doc),\n        on('ratechange', handler(4), doc),\n    ];\n    return callbackWrapper(() => {\n        handlers.forEach((h) => h());\n    });\n}\nfunction initFontObserver({ fontCb, doc }) {\n    const win = doc.defaultView;\n    if (!win) {\n        return () => {\n        };\n    }\n    const handlers = [];\n    const fontMap = new WeakMap();\n    const originalFontFace = win.FontFace;\n    win.FontFace = function FontFace(family, source, descriptors) {\n        const fontFace = new originalFontFace(family, source, descriptors);\n        fontMap.set(fontFace, {\n            family,\n            buffer: typeof source !== 'string',\n            descriptors,\n            fontSource: typeof source === 'string'\n                ? source\n                : JSON.stringify(Array.from(new Uint8Array(source))),\n        });\n        return fontFace;\n    };\n    const restoreHandler = patch(doc.fonts, 'add', function (original) {\n        return function (fontFace) {\n            setTimeout$1(callbackWrapper(() => {\n                const p = fontMap.get(fontFace);\n                if (p) {\n                    fontCb(p);\n                    fontMap.delete(fontFace);\n                }\n            }), 0);\n            return original.apply(this, [fontFace]);\n        };\n    });\n    handlers.push(() => {\n        win.FontFace = originalFontFace;\n    });\n    handlers.push(restoreHandler);\n    return callbackWrapper(() => {\n        handlers.forEach((h) => h());\n    });\n}\nfunction initSelectionObserver(param) {\n    const { doc, mirror, blockClass, blockSelector, unblockSelector, selectionCb, } = param;\n    let collapsed = true;\n    const updateSelection = callbackWrapper(() => {\n        const selection = doc.getSelection();\n        if (!selection || (collapsed && _optionalChain$2([selection, 'optionalAccess', _21 => _21.isCollapsed])))\n            return;\n        collapsed = selection.isCollapsed || false;\n        const ranges = [];\n        const count = selection.rangeCount || 0;\n        for (let i = 0; i < count; i++) {\n            const range = selection.getRangeAt(i);\n            const { startContainer, startOffset, endContainer, endOffset } = range;\n            const blocked = isBlocked(startContainer, blockClass, blockSelector, unblockSelector, true) ||\n                isBlocked(endContainer, blockClass, blockSelector, unblockSelector, true);\n            if (blocked)\n                continue;\n            ranges.push({\n                start: mirror.getId(startContainer),\n                startOffset,\n                end: mirror.getId(endContainer),\n                endOffset,\n            });\n        }\n        selectionCb({ ranges });\n    });\n    updateSelection();\n    return on('selectionchange', updateSelection);\n}\nfunction initCustomElementObserver({ doc, customElementCb, }) {\n    const win = doc.defaultView;\n    if (!win || !win.customElements)\n        return () => { };\n    const restoreHandler = patch(win.customElements, 'define', function (original) {\n        return function (name, constructor, options) {\n            try {\n                customElementCb({\n                    define: {\n                        name,\n                    },\n                });\n            }\n            catch (e) {\n            }\n            return original.apply(this, [name, constructor, options]);\n        };\n    });\n    return restoreHandler;\n}\nfunction initObservers(o, _hooks = {}) {\n    const currentWindow = o.doc.defaultView;\n    if (!currentWindow) {\n        return () => {\n        };\n    }\n    let mutationObserver;\n    if (o.recordDOM) {\n        mutationObserver = initMutationObserver(o, o.doc);\n    }\n    const mousemoveHandler = initMoveObserver(o);\n    const mouseInteractionHandler = initMouseInteractionObserver(o);\n    const scrollHandler = initScrollObserver(o);\n    const viewportResizeHandler = initViewportResizeObserver(o, {\n        win: currentWindow,\n    });\n    const inputHandler = initInputObserver(o);\n    const mediaInteractionHandler = initMediaInteractionObserver(o);\n    let styleSheetObserver = () => { };\n    let adoptedStyleSheetObserver = () => { };\n    let styleDeclarationObserver = () => { };\n    let fontObserver = () => { };\n    if (o.recordDOM) {\n        styleSheetObserver = initStyleSheetObserver(o, { win: currentWindow });\n        adoptedStyleSheetObserver = initAdoptedStyleSheetObserver(o, o.doc);\n        styleDeclarationObserver = initStyleDeclarationObserver(o, {\n            win: currentWindow,\n        });\n        if (o.collectFonts) {\n            fontObserver = initFontObserver(o);\n        }\n    }\n    const selectionObserver = initSelectionObserver(o);\n    const customElementObserver = initCustomElementObserver(o);\n    const pluginHandlers = [];\n    for (const plugin of o.plugins) {\n        pluginHandlers.push(plugin.observer(plugin.callback, currentWindow, plugin.options));\n    }\n    return callbackWrapper(() => {\n        mutationBuffers.forEach((b) => b.reset());\n        _optionalChain$2([mutationObserver, 'optionalAccess', _22 => _22.disconnect, 'call', _23 => _23()]);\n        mousemoveHandler();\n        mouseInteractionHandler();\n        scrollHandler();\n        viewportResizeHandler();\n        inputHandler();\n        mediaInteractionHandler();\n        styleSheetObserver();\n        adoptedStyleSheetObserver();\n        styleDeclarationObserver();\n        fontObserver();\n        selectionObserver();\n        customElementObserver();\n        pluginHandlers.forEach((h) => h());\n    });\n}\nfunction hasNestedCSSRule(prop) {\n    return typeof window[prop] !== 'undefined';\n}\nfunction canMonkeyPatchNestedCSSRule(prop) {\n    return Boolean(typeof window[prop] !== 'undefined' &&\n        window[prop].prototype &&\n        'insertRule' in window[prop].prototype &&\n        'deleteRule' in window[prop].prototype);\n}\n\nclass CrossOriginIframeMirror {\n    constructor(generateIdFn) {\n        this.generateIdFn = generateIdFn;\n        this.iframeIdToRemoteIdMap = new WeakMap();\n        this.iframeRemoteIdToIdMap = new WeakMap();\n    }\n    getId(iframe, remoteId, idToRemoteMap, remoteToIdMap) {\n        const idToRemoteIdMap = idToRemoteMap || this.getIdToRemoteIdMap(iframe);\n        const remoteIdToIdMap = remoteToIdMap || this.getRemoteIdToIdMap(iframe);\n        let id = idToRemoteIdMap.get(remoteId);\n        if (!id) {\n            id = this.generateIdFn();\n            idToRemoteIdMap.set(remoteId, id);\n            remoteIdToIdMap.set(id, remoteId);\n        }\n        return id;\n    }\n    getIds(iframe, remoteId) {\n        const idToRemoteIdMap = this.getIdToRemoteIdMap(iframe);\n        const remoteIdToIdMap = this.getRemoteIdToIdMap(iframe);\n        return remoteId.map((id) => this.getId(iframe, id, idToRemoteIdMap, remoteIdToIdMap));\n    }\n    getRemoteId(iframe, id, map) {\n        const remoteIdToIdMap = map || this.getRemoteIdToIdMap(iframe);\n        if (typeof id !== 'number')\n            return id;\n        const remoteId = remoteIdToIdMap.get(id);\n        if (!remoteId)\n            return -1;\n        return remoteId;\n    }\n    getRemoteIds(iframe, ids) {\n        const remoteIdToIdMap = this.getRemoteIdToIdMap(iframe);\n        return ids.map((id) => this.getRemoteId(iframe, id, remoteIdToIdMap));\n    }\n    reset(iframe) {\n        if (!iframe) {\n            this.iframeIdToRemoteIdMap = new WeakMap();\n            this.iframeRemoteIdToIdMap = new WeakMap();\n            return;\n        }\n        this.iframeIdToRemoteIdMap.delete(iframe);\n        this.iframeRemoteIdToIdMap.delete(iframe);\n    }\n    getIdToRemoteIdMap(iframe) {\n        let idToRemoteIdMap = this.iframeIdToRemoteIdMap.get(iframe);\n        if (!idToRemoteIdMap) {\n            idToRemoteIdMap = new Map();\n            this.iframeIdToRemoteIdMap.set(iframe, idToRemoteIdMap);\n        }\n        return idToRemoteIdMap;\n    }\n    getRemoteIdToIdMap(iframe) {\n        let remoteIdToIdMap = this.iframeRemoteIdToIdMap.get(iframe);\n        if (!remoteIdToIdMap) {\n            remoteIdToIdMap = new Map();\n            this.iframeRemoteIdToIdMap.set(iframe, remoteIdToIdMap);\n        }\n        return remoteIdToIdMap;\n    }\n}\n\nfunction _optionalChain$1(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }\nclass IframeManagerNoop {\n    constructor() {\n        this.crossOriginIframeMirror = new CrossOriginIframeMirror(genId);\n        this.crossOriginIframeRootIdMap = new WeakMap();\n    }\n    addIframe() {\n    }\n    addLoadListener() {\n    }\n    attachIframe() {\n    }\n}\nclass IframeManager {\n    constructor(options) {\n        this.iframes = new WeakMap();\n        this.crossOriginIframeMap = new WeakMap();\n        this.crossOriginIframeMirror = new CrossOriginIframeMirror(genId);\n        this.crossOriginIframeRootIdMap = new WeakMap();\n        this.mutationCb = options.mutationCb;\n        this.wrappedEmit = options.wrappedEmit;\n        this.stylesheetManager = options.stylesheetManager;\n        this.recordCrossOriginIframes = options.recordCrossOriginIframes;\n        this.crossOriginIframeStyleMirror = new CrossOriginIframeMirror(this.stylesheetManager.styleMirror.generateId.bind(this.stylesheetManager.styleMirror));\n        this.mirror = options.mirror;\n        if (this.recordCrossOriginIframes) {\n            window.addEventListener('message', this.handleMessage.bind(this));\n        }\n    }\n    addIframe(iframeEl) {\n        this.iframes.set(iframeEl, true);\n        if (iframeEl.contentWindow)\n            this.crossOriginIframeMap.set(iframeEl.contentWindow, iframeEl);\n    }\n    addLoadListener(cb) {\n        this.loadListener = cb;\n    }\n    attachIframe(iframeEl, childSn) {\n        this.mutationCb({\n            adds: [\n                {\n                    parentId: this.mirror.getId(iframeEl),\n                    nextId: null,\n                    node: childSn,\n                },\n            ],\n            removes: [],\n            texts: [],\n            attributes: [],\n            isAttachIframe: true,\n        });\n        _optionalChain$1([this, 'access', _ => _.loadListener, 'optionalCall', _2 => _2(iframeEl)]);\n        const iframeDoc = getIFrameContentDocument(iframeEl);\n        if (iframeDoc &&\n            iframeDoc.adoptedStyleSheets &&\n            iframeDoc.adoptedStyleSheets.length > 0)\n            this.stylesheetManager.adoptStyleSheets(iframeDoc.adoptedStyleSheets, this.mirror.getId(iframeDoc));\n    }\n    handleMessage(message) {\n        const crossOriginMessageEvent = message;\n        if (crossOriginMessageEvent.data.type !== 'rrweb' ||\n            crossOriginMessageEvent.origin !== crossOriginMessageEvent.data.origin)\n            return;\n        const iframeSourceWindow = message.source;\n        if (!iframeSourceWindow)\n            return;\n        const iframeEl = this.crossOriginIframeMap.get(message.source);\n        if (!iframeEl)\n            return;\n        const transformedEvent = this.transformCrossOriginEvent(iframeEl, crossOriginMessageEvent.data.event);\n        if (transformedEvent)\n            this.wrappedEmit(transformedEvent, crossOriginMessageEvent.data.isCheckout);\n    }\n    transformCrossOriginEvent(iframeEl, e) {\n        switch (e.type) {\n            case EventType.FullSnapshot: {\n                this.crossOriginIframeMirror.reset(iframeEl);\n                this.crossOriginIframeStyleMirror.reset(iframeEl);\n                this.replaceIdOnNode(e.data.node, iframeEl);\n                const rootId = e.data.node.id;\n                this.crossOriginIframeRootIdMap.set(iframeEl, rootId);\n                this.patchRootIdOnNode(e.data.node, rootId);\n                return {\n                    timestamp: e.timestamp,\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.Mutation,\n                        adds: [\n                            {\n                                parentId: this.mirror.getId(iframeEl),\n                                nextId: null,\n                                node: e.data.node,\n                            },\n                        ],\n                        removes: [],\n                        texts: [],\n                        attributes: [],\n                        isAttachIframe: true,\n                    },\n                };\n            }\n            case EventType.Meta:\n            case EventType.Load:\n            case EventType.DomContentLoaded: {\n                return false;\n            }\n            case EventType.Plugin: {\n                return e;\n            }\n            case EventType.Custom: {\n                this.replaceIds(e.data.payload, iframeEl, ['id', 'parentId', 'previousId', 'nextId']);\n                return e;\n            }\n            case EventType.IncrementalSnapshot: {\n                switch (e.data.source) {\n                    case IncrementalSource.Mutation: {\n                        e.data.adds.forEach((n) => {\n                            this.replaceIds(n, iframeEl, [\n                                'parentId',\n                                'nextId',\n                                'previousId',\n                            ]);\n                            this.replaceIdOnNode(n.node, iframeEl);\n                            const rootId = this.crossOriginIframeRootIdMap.get(iframeEl);\n                            rootId && this.patchRootIdOnNode(n.node, rootId);\n                        });\n                        e.data.removes.forEach((n) => {\n                            this.replaceIds(n, iframeEl, ['parentId', 'id']);\n                        });\n                        e.data.attributes.forEach((n) => {\n                            this.replaceIds(n, iframeEl, ['id']);\n                        });\n                        e.data.texts.forEach((n) => {\n                            this.replaceIds(n, iframeEl, ['id']);\n                        });\n                        return e;\n                    }\n                    case IncrementalSource.Drag:\n                    case IncrementalSource.TouchMove:\n                    case IncrementalSource.MouseMove: {\n                        e.data.positions.forEach((p) => {\n                            this.replaceIds(p, iframeEl, ['id']);\n                        });\n                        return e;\n                    }\n                    case IncrementalSource.ViewportResize: {\n                        return false;\n                    }\n                    case IncrementalSource.MediaInteraction:\n                    case IncrementalSource.MouseInteraction:\n                    case IncrementalSource.Scroll:\n                    case IncrementalSource.CanvasMutation:\n                    case IncrementalSource.Input: {\n                        this.replaceIds(e.data, iframeEl, ['id']);\n                        return e;\n                    }\n                    case IncrementalSource.StyleSheetRule:\n                    case IncrementalSource.StyleDeclaration: {\n                        this.replaceIds(e.data, iframeEl, ['id']);\n                        this.replaceStyleIds(e.data, iframeEl, ['styleId']);\n                        return e;\n                    }\n                    case IncrementalSource.Font: {\n                        return e;\n                    }\n                    case IncrementalSource.Selection: {\n                        e.data.ranges.forEach((range) => {\n                            this.replaceIds(range, iframeEl, ['start', 'end']);\n                        });\n                        return e;\n                    }\n                    case IncrementalSource.AdoptedStyleSheet: {\n                        this.replaceIds(e.data, iframeEl, ['id']);\n                        this.replaceStyleIds(e.data, iframeEl, ['styleIds']);\n                        _optionalChain$1([e, 'access', _3 => _3.data, 'access', _4 => _4.styles, 'optionalAccess', _5 => _5.forEach, 'call', _6 => _6((style) => {\n                            this.replaceStyleIds(style, iframeEl, ['styleId']);\n                        })]);\n                        return e;\n                    }\n                }\n            }\n        }\n        return false;\n    }\n    replace(iframeMirror, obj, iframeEl, keys) {\n        for (const key of keys) {\n            if (!Array.isArray(obj[key]) && typeof obj[key] !== 'number')\n                continue;\n            if (Array.isArray(obj[key])) {\n                obj[key] = iframeMirror.getIds(iframeEl, obj[key]);\n            }\n            else {\n                obj[key] = iframeMirror.getId(iframeEl, obj[key]);\n            }\n        }\n        return obj;\n    }\n    replaceIds(obj, iframeEl, keys) {\n        return this.replace(this.crossOriginIframeMirror, obj, iframeEl, keys);\n    }\n    replaceStyleIds(obj, iframeEl, keys) {\n        return this.replace(this.crossOriginIframeStyleMirror, obj, iframeEl, keys);\n    }\n    replaceIdOnNode(node, iframeEl) {\n        this.replaceIds(node, iframeEl, ['id', 'rootId']);\n        if ('childNodes' in node) {\n            node.childNodes.forEach((child) => {\n                this.replaceIdOnNode(child, iframeEl);\n            });\n        }\n    }\n    patchRootIdOnNode(node, rootId) {\n        if (node.type !== NodeType$3.Document && !node.rootId)\n            node.rootId = rootId;\n        if ('childNodes' in node) {\n            node.childNodes.forEach((child) => {\n                this.patchRootIdOnNode(child, rootId);\n            });\n        }\n    }\n}\n\nclass ShadowDomManagerNoop {\n    init() {\n    }\n    addShadowRoot() {\n    }\n    observeAttachShadow() {\n    }\n    reset() {\n    }\n}\nclass ShadowDomManager {\n    constructor(options) {\n        this.shadowDoms = new WeakSet();\n        this.restoreHandlers = [];\n        this.mutationCb = options.mutationCb;\n        this.scrollCb = options.scrollCb;\n        this.bypassOptions = options.bypassOptions;\n        this.mirror = options.mirror;\n        this.init();\n    }\n    init() {\n        this.reset();\n        this.patchAttachShadow(Element, document);\n    }\n    addShadowRoot(shadowRoot, doc) {\n        if (!isNativeShadowDom(shadowRoot))\n            return;\n        if (this.shadowDoms.has(shadowRoot))\n            return;\n        this.shadowDoms.add(shadowRoot);\n        this.bypassOptions.canvasManager.addShadowRoot(shadowRoot);\n        const observer = initMutationObserver({\n            ...this.bypassOptions,\n            doc,\n            mutationCb: this.mutationCb,\n            mirror: this.mirror,\n            shadowDomManager: this,\n        }, shadowRoot);\n        this.restoreHandlers.push(() => observer.disconnect());\n        this.restoreHandlers.push(initScrollObserver({\n            ...this.bypassOptions,\n            scrollCb: this.scrollCb,\n            doc: shadowRoot,\n            mirror: this.mirror,\n        }));\n        setTimeout$1(() => {\n            if (shadowRoot.adoptedStyleSheets &&\n                shadowRoot.adoptedStyleSheets.length > 0)\n                this.bypassOptions.stylesheetManager.adoptStyleSheets(shadowRoot.adoptedStyleSheets, this.mirror.getId(shadowRoot.host));\n            this.restoreHandlers.push(initAdoptedStyleSheetObserver({\n                mirror: this.mirror,\n                stylesheetManager: this.bypassOptions.stylesheetManager,\n            }, shadowRoot));\n        }, 0);\n    }\n    observeAttachShadow(iframeElement) {\n        const iframeDoc = getIFrameContentDocument(iframeElement);\n        const iframeWindow = getIFrameContentWindow(iframeElement);\n        if (!iframeDoc || !iframeWindow)\n            return;\n        this.patchAttachShadow(iframeWindow.Element, iframeDoc);\n    }\n    patchAttachShadow(element, doc) {\n        const manager = this;\n        this.restoreHandlers.push(patch(element.prototype, 'attachShadow', function (original) {\n            return function (option) {\n                const shadowRoot = original.call(this, option);\n                if (this.shadowRoot && inDom(this))\n                    manager.addShadowRoot(this.shadowRoot, doc);\n                return shadowRoot;\n            };\n        }));\n    }\n    reset() {\n        this.restoreHandlers.forEach((handler) => {\n            try {\n                handler();\n            }\n            catch (e) {\n            }\n        });\n        this.restoreHandlers = [];\n        this.shadowDoms = new WeakSet();\n        this.bypassOptions.canvasManager.resetShadowRoots();\n    }\n}\n\nclass CanvasManagerNoop {\n    reset() {\n    }\n    freeze() {\n    }\n    unfreeze() {\n    }\n    lock() {\n    }\n    unlock() {\n    }\n    snapshot() {\n    }\n    addWindow() {\n    }\n    addShadowRoot() {\n    }\n    resetShadowRoots() {\n    }\n}\n\nclass StylesheetManager {\n    constructor(options) {\n        this.trackedLinkElements = new WeakSet();\n        this.styleMirror = new StyleSheetMirror();\n        this.mutationCb = options.mutationCb;\n        this.adoptedStyleSheetCb = options.adoptedStyleSheetCb;\n    }\n    attachLinkElement(linkEl, childSn) {\n        if ('_cssText' in childSn.attributes)\n            this.mutationCb({\n                adds: [],\n                removes: [],\n                texts: [],\n                attributes: [\n                    {\n                        id: childSn.id,\n                        attributes: childSn\n                            .attributes,\n                    },\n                ],\n            });\n        this.trackLinkElement(linkEl);\n    }\n    trackLinkElement(linkEl) {\n        if (this.trackedLinkElements.has(linkEl))\n            return;\n        this.trackedLinkElements.add(linkEl);\n        this.trackStylesheetInLinkElement(linkEl);\n    }\n    adoptStyleSheets(sheets, hostId) {\n        if (sheets.length === 0)\n            return;\n        const adoptedStyleSheetData = {\n            id: hostId,\n            styleIds: [],\n        };\n        const styles = [];\n        for (const sheet of sheets) {\n            let styleId;\n            if (!this.styleMirror.has(sheet)) {\n                styleId = this.styleMirror.add(sheet);\n                styles.push({\n                    styleId,\n                    rules: Array.from(sheet.rules || CSSRule, (r, index) => ({\n                        rule: stringifyRule(r),\n                        index,\n                    })),\n                });\n            }\n            else\n                styleId = this.styleMirror.getId(sheet);\n            adoptedStyleSheetData.styleIds.push(styleId);\n        }\n        if (styles.length > 0)\n            adoptedStyleSheetData.styles = styles;\n        this.adoptedStyleSheetCb(adoptedStyleSheetData);\n    }\n    reset() {\n        this.styleMirror.reset();\n        this.trackedLinkElements = new WeakSet();\n    }\n    trackStylesheetInLinkElement(linkEl) {\n    }\n}\n\nclass ProcessedNodeManager {\n    constructor() {\n        this.nodeMap = new WeakMap();\n        this.active = false;\n    }\n    inOtherBuffer(node, thisBuffer) {\n        const buffers = this.nodeMap.get(node);\n        return (buffers && Array.from(buffers).some((buffer) => buffer !== thisBuffer));\n    }\n    add(node, buffer) {\n        if (!this.active) {\n            this.active = true;\n            onRequestAnimationFrame(() => {\n                this.nodeMap = new WeakMap();\n                this.active = false;\n            });\n        }\n        this.nodeMap.set(node, (this.nodeMap.get(node) || new Set()).add(buffer));\n    }\n    destroy() {\n    }\n}\n\nlet wrappedEmit;\nlet _takeFullSnapshot;\ntry {\n    if (Array.from([1], (x) => x * 2)[0] !== 2) {\n        const cleanFrame = document.createElement('iframe');\n        document.body.appendChild(cleanFrame);\n        Array.from = _optionalChain([cleanFrame, 'access', _ => _.contentWindow, 'optionalAccess', _2 => _2.Array, 'access', _3 => _3.from]) || Array.from;\n        document.body.removeChild(cleanFrame);\n    }\n}\ncatch (err) {\n    console.debug('Unable to override Array.from', err);\n}\nconst mirror = createMirror();\nfunction record(options = {}) {\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, recordDOM = true, recordCanvas = false, recordCrossOriginIframes = false, recordAfter = options.recordAfter === 'DOMContentLoaded'\n        ? options.recordAfter\n        : 'load', userTriggeredOnInput = false, collectFonts = false, inlineImages = false, plugins, keepIframeSrcFn = () => false, ignoreCSSAttributes = new Set([]), errorHandler, onMutation, getCanvasManager, } = options;\n    registerErrorHandler(errorHandler);\n    const inEmittingFrame = recordCrossOriginIframes\n        ? window.parent === window\n        : true;\n    let passEmitsToParent = false;\n    if (!inEmittingFrame) {\n        try {\n            if (window.parent.document) {\n                passEmitsToParent = false;\n            }\n        }\n        catch (e) {\n            passEmitsToParent = true;\n        }\n    }\n    if (inEmittingFrame && !emit) {\n        throw new Error('emit function is required');\n    }\n    if (!inEmittingFrame && !passEmitsToParent) {\n        return () => {\n        };\n    }\n    if (mousemoveWait !== undefined && sampling.mousemove === undefined) {\n        sampling.mousemove = mousemoveWait;\n    }\n    mirror.reset();\n    const maskInputOptions = maskAllInputs === true\n        ? {\n            color: true,\n            date: true,\n            'datetime-local': true,\n            email: true,\n            month: true,\n            number: true,\n            range: true,\n            search: true,\n            tel: true,\n            text: true,\n            time: true,\n            url: true,\n            week: true,\n            textarea: true,\n            select: true,\n            radio: true,\n            checkbox: true,\n        }\n        : _maskInputOptions !== undefined\n            ? _maskInputOptions\n            : {};\n    const slimDOMOptions = _slimDOMOptions === true || _slimDOMOptions === 'all'\n        ? {\n            script: true,\n            comment: true,\n            headFavicon: true,\n            headWhitespace: true,\n            headMetaSocial: true,\n            headMetaRobots: true,\n            headMetaHttpEquiv: true,\n            headMetaVerification: true,\n            headMetaAuthorship: _slimDOMOptions === 'all',\n            headMetaDescKeywords: _slimDOMOptions === 'all',\n        }\n        : _slimDOMOptions\n            ? _slimDOMOptions\n            : {};\n    polyfill();\n    let lastFullSnapshotEvent;\n    let incrementalSnapshotCount = 0;\n    const eventProcessor = (e) => {\n        for (const plugin of plugins || []) {\n            if (plugin.eventProcessor) {\n                e = plugin.eventProcessor(e);\n            }\n        }\n        if (packFn &&\n            !passEmitsToParent) {\n            e = packFn(e);\n        }\n        return e;\n    };\n    wrappedEmit = (r, isCheckout) => {\n        const e = r;\n        e.timestamp = nowTimestamp();\n        if (_optionalChain([mutationBuffers, 'access', _4 => _4[0], 'optionalAccess', _5 => _5.isFrozen, 'call', _6 => _6()]) &&\n            e.type !== EventType.FullSnapshot &&\n            !(e.type === EventType.IncrementalSnapshot &&\n                e.data.source === IncrementalSource.Mutation)) {\n            mutationBuffers.forEach((buf) => buf.unfreeze());\n        }\n        if (inEmittingFrame) {\n            _optionalChain([emit, 'optionalCall', _7 => _7(eventProcessor(e), isCheckout)]);\n        }\n        else if (passEmitsToParent) {\n            const message = {\n                type: 'rrweb',\n                event: eventProcessor(e),\n                origin: window.location.origin,\n                isCheckout,\n            };\n            window.parent.postMessage(message, '*');\n        }\n        if (e.type === EventType.FullSnapshot) {\n            lastFullSnapshotEvent = e;\n            incrementalSnapshotCount = 0;\n        }\n        else if (e.type === EventType.IncrementalSnapshot) {\n            if (e.data.source === IncrementalSource.Mutation &&\n                e.data.isAttachIframe) {\n                return;\n            }\n            incrementalSnapshotCount++;\n            const exceedCount = checkoutEveryNth && incrementalSnapshotCount >= checkoutEveryNth;\n            const exceedTime = checkoutEveryNms &&\n                lastFullSnapshotEvent &&\n                e.timestamp - lastFullSnapshotEvent.timestamp > checkoutEveryNms;\n            if (exceedCount || exceedTime) {\n                takeFullSnapshot(true);\n            }\n        }\n    };\n    const wrappedMutationEmit = (m) => {\n        wrappedEmit({\n            type: EventType.IncrementalSnapshot,\n            data: {\n                source: IncrementalSource.Mutation,\n                ...m,\n            },\n        });\n    };\n    const wrappedScrollEmit = (p) => wrappedEmit({\n        type: EventType.IncrementalSnapshot,\n        data: {\n            source: IncrementalSource.Scroll,\n            ...p,\n        },\n    });\n    const wrappedCanvasMutationEmit = (p) => wrappedEmit({\n        type: EventType.IncrementalSnapshot,\n        data: {\n            source: IncrementalSource.CanvasMutation,\n            ...p,\n        },\n    });\n    const wrappedAdoptedStyleSheetEmit = (a) => wrappedEmit({\n        type: EventType.IncrementalSnapshot,\n        data: {\n            source: IncrementalSource.AdoptedStyleSheet,\n            ...a,\n        },\n    });\n    const stylesheetManager = new StylesheetManager({\n        mutationCb: wrappedMutationEmit,\n        adoptedStyleSheetCb: wrappedAdoptedStyleSheetEmit,\n    });\n    const iframeManager = typeof __RRWEB_EXCLUDE_IFRAME__ === 'boolean' && __RRWEB_EXCLUDE_IFRAME__\n        ? new IframeManagerNoop()\n        : new IframeManager({\n            mirror,\n            mutationCb: wrappedMutationEmit,\n            stylesheetManager: stylesheetManager,\n            recordCrossOriginIframes,\n            wrappedEmit,\n        });\n    for (const plugin of plugins || []) {\n        if (plugin.getMirror)\n            plugin.getMirror({\n                nodeMirror: mirror,\n                crossOriginIframeMirror: iframeManager.crossOriginIframeMirror,\n                crossOriginIframeStyleMirror: iframeManager.crossOriginIframeStyleMirror,\n            });\n    }\n    const processedNodeManager = new ProcessedNodeManager();\n    const canvasManager = _getCanvasManager(getCanvasManager, {\n        mirror,\n        win: window,\n        mutationCb: (p) => wrappedEmit({\n            type: EventType.IncrementalSnapshot,\n            data: {\n                source: IncrementalSource.CanvasMutation,\n                ...p,\n            },\n        }),\n        recordCanvas,\n        blockClass,\n        blockSelector,\n        unblockSelector,\n        maxCanvasSize,\n        sampling: sampling['canvas'],\n        dataURLOptions,\n        errorHandler,\n    });\n    const shadowDomManager = typeof __RRWEB_EXCLUDE_SHADOW_DOM__ === 'boolean' &&\n        __RRWEB_EXCLUDE_SHADOW_DOM__\n        ? new ShadowDomManagerNoop()\n        : new ShadowDomManager({\n            mutationCb: wrappedMutationEmit,\n            scrollCb: wrappedScrollEmit,\n            bypassOptions: {\n                onMutation,\n                blockClass,\n                blockSelector,\n                unblockSelector,\n                maskAllText,\n                maskTextClass,\n                unmaskTextClass,\n                maskTextSelector,\n                unmaskTextSelector,\n                inlineStylesheet,\n                maskInputOptions,\n                dataURLOptions,\n                maskAttributeFn,\n                maskTextFn,\n                maskInputFn,\n                recordCanvas,\n                inlineImages,\n                sampling,\n                slimDOMOptions,\n                iframeManager,\n                stylesheetManager,\n                canvasManager,\n                keepIframeSrcFn,\n                processedNodeManager,\n            },\n            mirror,\n        });\n    const takeFullSnapshot = (isCheckout = false) => {\n        if (!recordDOM) {\n            return;\n        }\n        wrappedEmit({\n            type: EventType.Meta,\n            data: {\n                href: window.location.href,\n                width: getWindowWidth(),\n                height: getWindowHeight(),\n            },\n        }, isCheckout);\n        stylesheetManager.reset();\n        shadowDomManager.init();\n        mutationBuffers.forEach((buf) => buf.lock());\n        const node = snapshot(document, {\n            mirror,\n            blockClass,\n            blockSelector,\n            unblockSelector,\n            maskAllText,\n            maskTextClass,\n            unmaskTextClass,\n            maskTextSelector,\n            unmaskTextSelector,\n            inlineStylesheet,\n            maskAllInputs: maskInputOptions,\n            maskAttributeFn,\n            maskInputFn,\n            maskTextFn,\n            slimDOM: slimDOMOptions,\n            dataURLOptions,\n            recordCanvas,\n            inlineImages,\n            onSerialize: (n) => {\n                if (isSerializedIframe(n, mirror)) {\n                    iframeManager.addIframe(n);\n                }\n                if (isSerializedStylesheet(n, mirror)) {\n                    stylesheetManager.trackLinkElement(n);\n                }\n                if (hasShadowRoot(n)) {\n                    shadowDomManager.addShadowRoot(n.shadowRoot, document);\n                }\n            },\n            onIframeLoad: (iframe, childSn) => {\n                iframeManager.attachIframe(iframe, childSn);\n                if (iframe.contentWindow) {\n                    canvasManager.addWindow(iframe.contentWindow);\n                }\n                shadowDomManager.observeAttachShadow(iframe);\n            },\n            onStylesheetLoad: (linkEl, childSn) => {\n                stylesheetManager.attachLinkElement(linkEl, childSn);\n            },\n            keepIframeSrcFn,\n        });\n        if (!node) {\n            return console.warn('Failed to snapshot the document');\n        }\n        wrappedEmit({\n            type: EventType.FullSnapshot,\n            data: {\n                node,\n                initialOffset: getWindowScroll(window),\n            },\n        });\n        mutationBuffers.forEach((buf) => buf.unlock());\n        if (document.adoptedStyleSheets && document.adoptedStyleSheets.length > 0)\n            stylesheetManager.adoptStyleSheets(document.adoptedStyleSheets, mirror.getId(document));\n    };\n    _takeFullSnapshot = takeFullSnapshot;\n    try {\n        const handlers = [];\n        const observe = (doc) => {\n            return callbackWrapper(initObservers)({\n                onMutation,\n                mutationCb: wrappedMutationEmit,\n                mousemoveCb: (positions, source) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source,\n                        positions,\n                    },\n                }),\n                mouseInteractionCb: (d) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.MouseInteraction,\n                        ...d,\n                    },\n                }),\n                scrollCb: wrappedScrollEmit,\n                viewportResizeCb: (d) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.ViewportResize,\n                        ...d,\n                    },\n                }),\n                inputCb: (v) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.Input,\n                        ...v,\n                    },\n                }),\n                mediaInteractionCb: (p) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.MediaInteraction,\n                        ...p,\n                    },\n                }),\n                styleSheetRuleCb: (r) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.StyleSheetRule,\n                        ...r,\n                    },\n                }),\n                styleDeclarationCb: (r) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.StyleDeclaration,\n                        ...r,\n                    },\n                }),\n                canvasMutationCb: wrappedCanvasMutationEmit,\n                fontCb: (p) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.Font,\n                        ...p,\n                    },\n                }),\n                selectionCb: (p) => {\n                    wrappedEmit({\n                        type: EventType.IncrementalSnapshot,\n                        data: {\n                            source: IncrementalSource.Selection,\n                            ...p,\n                        },\n                    });\n                },\n                customElementCb: (c) => {\n                    wrappedEmit({\n                        type: EventType.IncrementalSnapshot,\n                        data: {\n                            source: IncrementalSource.CustomElement,\n                            ...c,\n                        },\n                    });\n                },\n                blockClass,\n                ignoreClass,\n                ignoreSelector,\n                maskAllText,\n                maskTextClass,\n                unmaskTextClass,\n                maskTextSelector,\n                unmaskTextSelector,\n                maskInputOptions,\n                inlineStylesheet,\n                sampling,\n                recordDOM,\n                recordCanvas,\n                inlineImages,\n                userTriggeredOnInput,\n                collectFonts,\n                doc,\n                maskAttributeFn,\n                maskInputFn,\n                maskTextFn,\n                keepIframeSrcFn,\n                blockSelector,\n                unblockSelector,\n                slimDOMOptions,\n                dataURLOptions,\n                mirror,\n                iframeManager,\n                stylesheetManager,\n                shadowDomManager,\n                processedNodeManager,\n                canvasManager,\n                ignoreCSSAttributes,\n                plugins: _optionalChain([plugins\n, 'optionalAccess', _8 => _8.filter, 'call', _9 => _9((p) => p.observer)\n, 'optionalAccess', _10 => _10.map, 'call', _11 => _11((p) => ({\n                    observer: p.observer,\n                    options: p.options,\n                    callback: (payload) => wrappedEmit({\n                        type: EventType.Plugin,\n                        data: {\n                            plugin: p.name,\n                            payload,\n                        },\n                    }),\n                }))]) || [],\n            }, {});\n        };\n        iframeManager.addLoadListener((iframeEl) => {\n            try {\n                handlers.push(observe(iframeEl.contentDocument));\n            }\n            catch (error) {\n                console.warn(error);\n            }\n        });\n        const init = () => {\n            takeFullSnapshot();\n            handlers.push(observe(document));\n        };\n        if (document.readyState === 'interactive' ||\n            document.readyState === 'complete') {\n            init();\n        }\n        else {\n            handlers.push(on('DOMContentLoaded', () => {\n                wrappedEmit({\n                    type: EventType.DomContentLoaded,\n                    data: {},\n                });\n                if (recordAfter === 'DOMContentLoaded')\n                    init();\n            }));\n            handlers.push(on('load', () => {\n                wrappedEmit({\n                    type: EventType.Load,\n                    data: {},\n                });\n                if (recordAfter === 'load')\n                    init();\n            }, window));\n        }\n        return () => {\n            handlers.forEach((h) => h());\n            processedNodeManager.destroy();\n            _takeFullSnapshot = undefined;\n            unregisterErrorHandler();\n        };\n    }\n    catch (error) {\n        console.warn(error);\n    }\n}\nfunction takeFullSnapshot(isCheckout) {\n    if (!_takeFullSnapshot) {\n        throw new Error('please take full snapshot after start recording');\n    }\n    _takeFullSnapshot(isCheckout);\n}\nrecord.mirror = mirror;\nrecord.takeFullSnapshot = takeFullSnapshot;\nfunction _getCanvasManager(getCanvasManagerFn, options) {\n    try {\n        return getCanvasManagerFn\n            ? getCanvasManagerFn(options)\n            : new CanvasManagerNoop();\n    }\n    catch (e2) {\n        console.warn('Unable to initialize CanvasManager');\n        return new CanvasManagerNoop();\n    }\n}\n\nconst ReplayEventTypeIncrementalSnapshot = 3;\nconst ReplayEventTypeCustom = 5;\n\n/**\n * Converts a timestamp to ms, if it was in s, or keeps it as ms.\n */\nfunction timestampToMs(timestamp) {\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 */\nfunction timestampToS(timestamp) {\n  const isMs = timestamp > 9999999999;\n  return isMs ? timestamp / 1000 : timestamp;\n}\n\n/**\n * Add a breadcrumb event to replay.\n */\nfunction addBreadcrumbEvent(replay, breadcrumb) {\n  if (breadcrumb.category === 'sentry.transaction') {\n    return;\n  }\n\n  if (['ui.click', 'ui.input'].includes(breadcrumb.category )) {\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, 1000),\n      },\n    });\n\n    // Do not flush after console log messages\n    return breadcrumb.category === 'console';\n  });\n}\n\nconst INTERACTIVE_SELECTOR = 'button,a';\n\n/** Get the closest interactive parent element, or else return the given element. */\nfunction getClosestInteractive(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 */\nfunction getClickTargetNode(event) {\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. */\nfunction getTargetNode(event) {\n  if (isEventWithTarget(event)) {\n    return event.target ;\n  }\n\n  return event;\n}\n\nfunction isEventWithTarget(event) {\n  return typeof event === 'object' && !!event && 'target' in event;\n}\n\nlet handlers;\n\n/**\n * Register a handler to be called when `window.open()` is called.\n * Returns a cleanup function.\n */\nfunction onWindowOpen(cb) {\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 ).splice(pos, 1);\n    }\n  };\n}\n\nfunction monkeyPatchWindowOpen() {\n  fill(WINDOW, 'open', function (originalWindowOpen) {\n    return function (...args) {\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\n/** Any IncrementalSource for rrweb that we interpret as a kind of mutation. */\nconst IncrementalMutationSources = new Set([\n  IncrementalSource.Mutation,\n  IncrementalSource.StyleSheetRule,\n  IncrementalSource.StyleDeclaration,\n  IncrementalSource.AdoptedStyleSheet,\n  IncrementalSource.CanvasMutation,\n  IncrementalSource.Selection,\n  IncrementalSource.MediaInteraction,\n]);\n\n/** Handle a click. */\nfunction handleClick(clickDetector, clickBreadcrumb, node) {\n  clickDetector.handleClick(clickBreadcrumb, node);\n}\n\n/** A click detector class that can be used to detect slow or rage clicks on elements. */\nclass ClickDetector  {\n  // protected for testing\n\n   constructor(\n    replay,\n    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._scrollTimeout = 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   addListeners() {\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   removeListeners() {\n    if (this._teardown) {\n      this._teardown();\n    }\n\n    if (this._checkClickTimeout) {\n      clearTimeout(this._checkClickTimeout);\n    }\n  }\n\n  /** @inheritDoc */\n   handleClick(breadcrumb, node) {\n    if (ignoreElement(node, this._ignoreSelector) || !isClickBreadcrumb(breadcrumb)) {\n      return;\n    }\n\n    const newClick = {\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   registerMutation(timestamp = Date.now()) {\n    this._lastMutation = timestampToS(timestamp);\n  }\n\n  /** @inheritDoc */\n   registerScroll(timestamp = Date.now()) {\n    this._lastScroll = timestampToS(timestamp);\n  }\n\n  /** @inheritDoc */\n   registerClick(element) {\n    const node = getClosestInteractive(element);\n    this._handleMultiClick(node );\n  }\n\n  /** Count multiple clicks on elements. */\n   _handleMultiClick(node) {\n    this._getClicks(node).forEach(click => {\n      click.clickCount++;\n    });\n  }\n\n  /** Get all pending clicks for a given node. */\n   _getClicks(node) {\n    return this._clicks.filter(click => click.node === node);\n  }\n\n  /** Check the clicks that happened. */\n   _checkClicks() {\n    const timedOutClicks = [];\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   _generateBreadcrumbs(click) {\n    const replay = this._replay;\n    const hadScroll = click.scrollAfter && click.scrollAfter <= this._scrollTimeout;\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 = {\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 = {\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   _scheduleCheckClicks() {\n    if (this._checkClickTimeout) {\n      clearTimeout(this._checkClickTimeout);\n    }\n\n    this._checkClickTimeout = setTimeout$3(() => this._checkClicks(), 1000);\n  }\n}\n\nconst SLOW_CLICK_TAGS = ['A', 'BUTTON', 'INPUT'];\n\n/** exported for tests only */\nfunction ignoreElement(node, ignoreSelector) {\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) {\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() {\n  return Date.now() / 1000;\n}\n\n/** Update the click detector based on a recording event of rrweb. */\nfunction updateClickDetectorForRecordingEvent(clickDetector, event) {\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 (IncrementalMutationSources.has(source)) {\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 (e) {\n    // ignore errors here, e.g. if accessing something that does not exist\n  }\n}\n\nfunction isIncrementalEvent(event) {\n  return event.type === ReplayEventTypeIncrementalSnapshot;\n}\n\nfunction isIncrementalMouseInteraction(\n  event,\n) {\n  return event.data.source === IncrementalSource.MouseInteraction;\n}\n\n/**\n * Create a breadcrumb for a replay.\n */\nfunction createBreadcrumb(\n  breadcrumb,\n) {\n  return {\n    timestamp: Date.now() / 1000,\n    type: 'default',\n    ...breadcrumb,\n  };\n}\n\nvar NodeType;\n(function (NodeType) {\n    NodeType[NodeType[\"Document\"] = 0] = \"Document\";\n    NodeType[NodeType[\"DocumentType\"] = 1] = \"DocumentType\";\n    NodeType[NodeType[\"Element\"] = 2] = \"Element\";\n    NodeType[NodeType[\"Text\"] = 3] = \"Text\";\n    NodeType[NodeType[\"CDATA\"] = 4] = \"CDATA\";\n    NodeType[NodeType[\"Comment\"] = 5] = \"Comment\";\n})(NodeType || (NodeType = {}));\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 */\nfunction getAttributesToRecord(attributes) {\n  const obj = {};\n  if (!attributes['data-sentry-component'] && attributes['data-sentry-element']) {\n    attributes['data-sentry-component'] = attributes['data-sentry-element'];\n  }\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\nconst handleDomListener = (\n  replay,\n) => {\n  return (handlerData) => {\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 ) : 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 ,\n        getClickTargetNode(handlerData.event ) ,\n      );\n    }\n\n    addBreadcrumbEvent(replay, result);\n  };\n};\n\n/** Get the base DOM breadcrumb. */\nfunction getBaseDomBreadcrumb(target, message) {\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) => node.type === NodeType.Text && node.textContent)\n              .filter(Boolean) // filter out empty values\n              .map(text => (text ).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 */\nfunction handleDom(handlerData) {\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) {\n  const isClick = handlerData.name === 'click';\n\n  let message;\n  let target = null;\n\n  // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n  try {\n    target = isClick ? getClickTargetNode(handlerData.event ) : getTargetNode(handlerData.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) {\n  return node.type === NodeType.Element;\n}\n\n/** Handle keyboard events & create breadcrumbs. */\nfunction handleKeyboardEvent(replay, event) {\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 */\nfunction getKeyboardBreadcrumb(event) {\n  const { metaKey, shiftKey, ctrlKey, altKey, key, target } = event;\n\n  // never capture for input fields\n  if (!target || isInputElement(target ) || !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 , 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) {\n  return target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable;\n}\n\n// Map entryType -> function to normalize data for event\nconst ENTRY_TYPES\n\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 * Handler creater for web vitals\n */\nfunction webVitalHandler(\n  getter,\n  replay,\n) {\n  return ({ metric }) => void replay.replayPerformanceEntries.push(getter(metric));\n}\n\n/**\n * Create replay performance entries from the browser performance entries.\n */\nfunction createPerformanceEntries(\n  entries,\n) {\n  return entries.map(createPerformanceEntry).filter(Boolean) ;\n}\n\nfunction createPerformanceEntry(entry) {\n  const entryType = ENTRY_TYPES[entry.entryType];\n  if (!entryType) {\n    return null;\n  }\n\n  return entryType(entry);\n}\n\nfunction getAbsoluteTime(time) {\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) {\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) {\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,\n) {\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 a LCP metric.\n */\nfunction getLargestContentfulPaint(metric) {\n  const lastEntry = metric.entries[metric.entries.length - 1] ;\n  const node = lastEntry && lastEntry.element ? [lastEntry.element] : undefined;\n  return getWebVital(metric, 'largest-contentful-paint', node);\n}\n\nfunction isLayoutShift(entry) {\n  return (entry ).sources !== undefined;\n}\n\n/**\n * Add a CLS event to the replay based on a CLS metric.\n */\nfunction getCumulativeLayoutShift(metric) {\n  const layoutShifts = [];\n  const nodes = [];\n  for (const entry of metric.entries) {\n    if (isLayoutShift(entry)) {\n      const nodeIds = [];\n      for (const source of entry.sources) {\n        if (source.node) {\n          nodes.push(source.node);\n          const nodeId = record.mirror.getId(source.node);\n          if (nodeId) {\n            nodeIds.push(nodeId);\n          }\n        }\n      }\n      layoutShifts.push({ value: entry.value, nodeIds: nodeIds.length ? nodeIds : undefined });\n    }\n  }\n\n  return getWebVital(metric, 'cumulative-layout-shift', nodes, layoutShifts);\n}\n\n/**\n * Add a FID event to the replay based on a FID metric.\n */\nfunction getFirstInputDelay(metric) {\n  const lastEntry = metric.entries[metric.entries.length - 1] ;\n  const node = lastEntry && lastEntry.target ? [lastEntry.target] : undefined;\n  return getWebVital(metric, 'first-input-delay', node);\n}\n\n/**\n * Add an INP event to the replay based on an INP metric.\n */\nfunction getInteractionToNextPaint(metric) {\n  const lastEntry = metric.entries[metric.entries.length - 1] ;\n  const node = lastEntry && lastEntry.target ? [lastEntry.target] : undefined;\n  return getWebVital(metric, 'interaction-to-next-paint', node);\n}\n\n/**\n * Add an web vital event to the replay based on the web vital metric.\n */\nfunction getWebVital(\n  metric,\n  name,\n  nodes,\n  attributions,\n) {\n  const value = metric.value;\n  const rating = metric.rating;\n\n  const end = getAbsoluteTime(value);\n\n  return {\n    type: 'web-vital',\n    name,\n    start: end,\n    end,\n    data: {\n      value,\n      size: value,\n      rating,\n      nodeIds: nodes ? nodes.map(node => record.mirror.getId(node)) : undefined,\n      attributions,\n    },\n  };\n}\n\n/**\n * Sets up a PerformanceObserver to listen to all performance entry types.\n * Returns a callback to stop observing.\n */\nfunction setupPerformanceObserver(replay) {\n  function addPerformanceEntry(entry) {\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 }) {\n    entries.forEach(addPerformanceEntry);\n  }\n\n  const clearCallbacks = [];\n\n  (['navigation', 'paint', 'resource'] ).forEach(type => {\n    clearCallbacks.push(addPerformanceInstrumentationHandler(type, onEntries));\n  });\n\n  clearCallbacks.push(\n    addLcpInstrumentationHandler(webVitalHandler(getLargestContentfulPaint, replay)),\n    addClsInstrumentationHandler(webVitalHandler(getCumulativeLayoutShift, replay)),\n    addFidInstrumentationHandler(webVitalHandler(getFirstInputDelay, replay)),\n    addInpInstrumentationHandler(webVitalHandler(getInteractionToNextPaint, replay)),\n  );\n\n  // A callback to cleanup all handlers\n  return () => {\n    clearCallbacks.forEach(clearCallback => clearCallback());\n  };\n}\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 */\nconst DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);\n\nconst r = `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==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},_=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},x=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=A(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}},A=function(t,n,r){return-1==t.s?Math.max(A(t.l,n,r+1),A(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)},U=function(t,r,s,o,f,h,l,u,c,v,m){z(r,m++,s),++f[256];for(var b=x(f,15),M=b.t,E=b.l,A=x(h,15),U=A.t,C=A.l,F=D(M),I=F.c,S=F.n,L=D(U),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=x(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,U)+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(U,C,0),R=U;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){_(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;_(r,m,Q[et]),m+=R[et],et>3&&(_(r,m,rt>>5&8191),m+=i[et])}else _(r,m,N[rt]),m+=P[rt]}return _(r,m,N[256]),m+P[256]},C=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;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}}},L=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}}},O=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=C[s-1],M=y>>13,E=8191&y,z=(1<<o)-1,_=c.p||new n(32768),x=c.h||new n(z+1),A=Math.ceil(o/3),D=2*A,T=function(t){return(a[t]^a[t+1]<<A^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=x[H];if(_[J]=K,x[H]=J,B<=j){var N=v-j;if((L>7e3||q>24576)&&(N>423||!w)){p=U(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-_[rt]&32767;et>nt&&(nt=et,K=rt)}}}W+=(J=K)-(K=_[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=U(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=x,c.p=_,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)},j=function(t,n,r){for(;r;++n)t[n]=r,r>>>=8},q=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&&j(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)}},B=function(t){return 10+(t.filename?t.filename.length+1:0)},G=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(O(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}();var H=function(){function t(t,n){this.c=L(),this.v=1,G.call(this,t,n)}return t.prototype.push=function(t,n){this.c.p(t),G.prototype.push.call(this,t,n)},t.prototype.p=function(t,n){var r=O(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=L();i.p(n.dictionary),j(t,2,i.d())}}(r,this.o),this.v=0),n&&j(r,r.length-4,this.c.d()),this.ondata(r,n)},t}(),J=\"undefined\"!=typeof TextEncoder&&new TextEncoder,K=\"undefined\"!=typeof TextDecoder&&new TextDecoder;try{K.decode(F,{stream:!0})}catch(t){}var N=function(){function t(t){this.ondata=t}return t.prototype.push=function(t,n){this.ondata||E(5),this.d&&E(4),this.ondata(P(t),this.d=n||!1)},t}();function P(n,r){if(J)return J.encode(n);for(var e=n.length,i=new t(n.length+(n.length>>1)),a=0,s=function(t){i[a++]=t},o=0;o<e;++o){if(a+5>i.length){var f=new t(a+8+(e-o<<1));f.set(i),i=f}var h=n.charCodeAt(o);h<128||r?s(h):h<2048?(s(192|h>>6),s(128|63&h)):h>55295&&h<57344?(s(240|(h=65536+(1047552&h)|1023&n.charCodeAt(++o))>>18),s(128|h>>12&63),s(128|h>>6&63),s(128|63&h)):(s(224|h>>12),s(128|h>>6&63),s(128|63&h))}return b(i,0,a)}function Q(t){return function(t,n){n||(n={});var r=S(),e=t.length;r.p(t);var i=O(t,n,B(n),8),a=i.length;return q(i,n),j(i,a-8,r.d()),j(i,a-4,e),i}(P(t))}const R=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(const r of t)n+=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 H,this.deflate.ondata=(t,n)=>{this._deflatedData.push(t)},this.stream=new N(((t,n)=>{this.deflate.push(t,n)})),this.stream.push(\"[\")}},V={clear:()=>{R.clear()},addEvent:t=>R.addEvent(t),finish:()=>R.finish(),compress:t=>Q(t)};addEventListener(\"message\",(function(t){const n=t.data.method,r=t.data.id,e=t.data.arg;if(n in V&&\"function\"==typeof V[n])try{const t=V[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\nfunction e(){const e=new Blob([r]);return URL.createObjectURL(e)}\n\nconst CONSOLE_LEVELS = ['info', 'warn', 'error', 'log'] ;\nconst PREFIX = '[Replay] ';\n\nfunction _addBreadcrumb(message, level = 'info') {\n  addBreadcrumb(\n    {\n      category: 'console',\n      data: {\n        logger: 'replay',\n      },\n      level,\n      message: `${PREFIX}${message}`,\n    },\n    { level },\n  );\n}\n\nfunction makeReplayLogger() {\n  let _capture = false;\n  let _trace = false;\n\n  const _logger = {\n    exception: () => undefined,\n    infoTick: () => undefined,\n    setConfig: (opts) => {\n      _capture = opts.captureExceptions;\n      _trace = opts.traceInternals;\n    },\n  };\n\n  if (DEBUG_BUILD) {\n    CONSOLE_LEVELS.forEach(name => {\n      _logger[name] = (...args) => {\n        logger$1[name](PREFIX, ...args);\n        if (_trace) {\n          _addBreadcrumb(args.join(''), severityLevelFromString(name));\n        }\n      };\n    });\n\n    _logger.exception = (error, ...message) => {\n      if (message.length && _logger.error) {\n        _logger.error(...message);\n      }\n\n      logger$1.error(PREFIX, error);\n\n      if (_capture) {\n        captureException(error);\n      } else if (_trace) {\n        // No need for a breadcrumb if `_capture` is enabled since it should be\n        // captured as an exception\n        _addBreadcrumb(error, 'error');\n      }\n    };\n\n    _logger.infoTick = (...args) => {\n      logger$1.info(PREFIX, ...args);\n      if (_trace) {\n        // Wait a tick here to avoid race conditions for some initial logs\n        // which may be added before replay is initialized\n        setTimeout(() => _addBreadcrumb(args[0]), 0);\n      }\n    };\n  } else {\n    CONSOLE_LEVELS.forEach(name => {\n      _logger[name] = () => undefined;\n    });\n  }\n\n  return _logger ;\n}\n\nconst logger = makeReplayLogger();\n\n/** This error indicates that the event buffer size exceeded the limit.. */\nclass EventBufferSizeExceededError extends Error {\n   constructor() {\n    super(`Event buffer exceeded maximum size of ${REPLAY_MAX_EVENT_BUFFER_SIZE}.`);\n  }\n}\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 */\nclass EventBufferArray  {\n  /** All the events that are buffered to be sent. */\n\n  /** @inheritdoc */\n\n  /** @inheritdoc */\n\n   constructor() {\n    this.events = [];\n    this._totalSize = 0;\n    this.hasCheckout = false;\n    this.waitForCheckout = false;\n  }\n\n  /** @inheritdoc */\n   get hasEvents() {\n    return this.events.length > 0;\n  }\n\n  /** @inheritdoc */\n   get type() {\n    return 'sync';\n  }\n\n  /** @inheritdoc */\n   destroy() {\n    this.events = [];\n  }\n\n  /** @inheritdoc */\n   async addEvent(event) {\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   finish() {\n    return new Promise(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   clear() {\n    this.events = [];\n    this._totalSize = 0;\n    this.hasCheckout = false;\n  }\n\n  /** @inheritdoc */\n   getEarliestTimestamp() {\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\n/**\n * Event buffer that uses a web worker to compress events.\n * Exported only for testing.\n */\nclass WorkerHandler {\n\n   constructor(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 occurred.\n   */\n   ensureReady() {\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 }) => {\n          if ((data ).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   destroy() {\n    DEBUG_BUILD && logger.info('Destroying compression worker');\n    this._worker.terminate();\n  }\n\n  /**\n   * Post message to worker and wait for response before resolving promise.\n   */\n   postMessage(method, arg) {\n    const id = this._getAndIncrementId();\n\n    return new Promise((resolve, reject) => {\n      const listener = ({ data }) => {\n        const response = data ;\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('Error in compression worker: ', response.response);\n\n          reject(new Error('Error in compression worker'));\n          return;\n        }\n\n        resolve(response.response );\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   _getAndIncrementId() {\n    return this._id++;\n  }\n}\n\n/**\n * Event buffer that uses a web worker to compress events.\n * Exported only for testing.\n */\nclass EventBufferCompressionWorker  {\n  /** @inheritdoc */\n\n  /** @inheritdoc */\n\n   constructor(worker) {\n    this._worker = new WorkerHandler(worker);\n    this._earliestTimestamp = null;\n    this._totalSize = 0;\n    this.hasCheckout = false;\n    this.waitForCheckout = false;\n  }\n\n  /** @inheritdoc */\n   get hasEvents() {\n    return !!this._earliestTimestamp;\n  }\n\n  /** @inheritdoc */\n   get type() {\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 occurred.\n   */\n   ensureReady() {\n    return this._worker.ensureReady();\n  }\n\n  /**\n   * Destroy the event buffer.\n   */\n   destroy() {\n    this._worker.destroy();\n  }\n\n  /**\n   * Add an event to the event buffer.\n   *\n   * Returns true if event was successfully received and processed by worker.\n   */\n   addEvent(event) {\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   finish() {\n    return this._finishRequest();\n  }\n\n  /** @inheritdoc */\n   clear() {\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.exception(e, 'Sending \"clear\" message to worker failed', e);\n    });\n  }\n\n  /** @inheritdoc */\n   getEarliestTimestamp() {\n    return this._earliestTimestamp;\n  }\n\n  /**\n   * Send the event to the worker.\n   */\n   _sendEventToWorker(data) {\n    return this._worker.postMessage('addEvent', data);\n  }\n\n  /**\n   * Finish the request and return the compressed data from the worker.\n   */\n   async _finishRequest() {\n    const response = await this._worker.postMessage('finish');\n\n    this._earliestTimestamp = null;\n    this._totalSize = 0;\n\n    return response;\n  }\n}\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 */\nclass EventBufferProxy  {\n\n   constructor(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   get waitForCheckout() {\n    return this._used.waitForCheckout;\n  }\n\n  /** @inheritdoc */\n   get type() {\n    return this._used.type;\n  }\n\n  /** @inheritDoc */\n   get hasEvents() {\n    return this._used.hasEvents;\n  }\n\n  /** @inheritdoc */\n   get hasCheckout() {\n    return this._used.hasCheckout;\n  }\n  /** @inheritdoc */\n   set hasCheckout(value) {\n    this._used.hasCheckout = value;\n  }\n\n  /** @inheritdoc */\n  // eslint-disable-next-line @typescript-eslint/adjacent-overload-signatures\n   set waitForCheckout(value) {\n    this._used.waitForCheckout = value;\n  }\n\n  /** @inheritDoc */\n   destroy() {\n    this._fallback.destroy();\n    this._compression.destroy();\n  }\n\n  /** @inheritdoc */\n   clear() {\n    return this._used.clear();\n  }\n\n  /** @inheritdoc */\n   getEarliestTimestamp() {\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   addEvent(event) {\n    return this._used.addEvent(event);\n  }\n\n  /** @inheritDoc */\n   async finish() {\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   ensureWorkerIsLoaded() {\n    return this._ensureWorkerIsLoadedPromise;\n  }\n\n  /** Actually check if the worker has been loaded. */\n   async _ensureWorkerIsLoaded() {\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      DEBUG_BUILD && logger.exception(error, '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   async _switchToCompressionWorker() {\n    const { events, hasCheckout, waitForCheckout } = this._fallback;\n\n    const addEventPromises = [];\n    for (const event of events) {\n      addEventPromises.push(this._compression.addEvent(event));\n    }\n\n    this._compression.hasCheckout = hasCheckout;\n    this._compression.waitForCheckout = waitForCheckout;\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\n      // Can now clear fallback buffer as it's no longer necessary\n      this._fallback.clear();\n    } catch (error) {\n      DEBUG_BUILD && logger.exception(error, 'Failed to add events when switching buffers.');\n    }\n  }\n}\n\n/**\n * Create an event buffer for replays.\n */\nfunction createEventBuffer({\n  useCompression,\n  workerUrl: customWorkerUrl,\n}) {\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  DEBUG_BUILD && logger.info('Using simple buffer');\n  return new EventBufferArray();\n}\n\nfunction _loadWorker(customWorkerUrl) {\n  try {\n    const workerUrl = customWorkerUrl || _getWorkerUrl();\n\n    if (!workerUrl) {\n      return;\n    }\n\n    DEBUG_BUILD && logger.info(`Using compression worker${customWorkerUrl ? ` from ${customWorkerUrl}` : ''}`);\n    const worker = new Worker(workerUrl);\n    return new EventBufferProxy(worker);\n  } catch (error) {\n    DEBUG_BUILD && logger.exception(error, 'Failed to create compression worker');\n    // Fall back to use simple event buffer array\n  }\n}\n\nfunction _getWorkerUrl() {\n  if (typeof __SENTRY_EXCLUDE_REPLAY_WORKER__ === 'undefined' || !__SENTRY_EXCLUDE_REPLAY_WORKER__) {\n    return e();\n  }\n\n  return '';\n}\n\n/** If sessionStorage is available. */\nfunction hasSessionStorage() {\n  try {\n    // This can throw, e.g. when being accessed in a sandboxed iframe\n    return 'sessionStorage' in WINDOW && !!WINDOW.sessionStorage;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Removes the session from Session Storage and unsets session in replay instance\n */\nfunction clearSession(replay) {\n  deleteSession();\n  replay.session = undefined;\n}\n\n/**\n * Deletes a session from storage\n */\nfunction deleteSession() {\n  if (!hasSessionStorage()) {\n    return;\n  }\n\n  try {\n    WINDOW.sessionStorage.removeItem(REPLAY_SESSION_KEY);\n  } catch (e) {\n    // Ignore potential SecurityError exceptions\n  }\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 */\nfunction isSampled(sampleRate) {\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\n/**\n * Get a session with defaults & applied sampling.\n */\nfunction makeSession(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\n/**\n * Save a session to session storage.\n */\nfunction saveSession(session) {\n  if (!hasSessionStorage()) {\n    return;\n  }\n\n  try {\n    WINDOW.sessionStorage.setItem(REPLAY_SESSION_KEY, JSON.stringify(session));\n  } catch (e) {\n    // Ignore potential SecurityError exceptions\n  }\n}\n\n/**\n * Get the sampled status for a session based on sample rates & current sampled status.\n */\nfunction getSessionSampleType(sessionSampleRate, allowBuffering) {\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 */\nfunction createSession(\n  { sessionSampleRate, allowBuffering, stickySession = false },\n  { previousSessionId } = {},\n) {\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/**\n * Fetches a session from storage\n */\nfunction fetchSession() {\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) ;\n\n    DEBUG_BUILD && logger.infoTick('Loading existing session');\n\n    return makeSession(sessionObj);\n  } catch (e) {\n    return null;\n  }\n}\n\n/**\n * Given an initial timestamp and an expiry duration, checks to see if current\n * time should be considered as expired.\n */\nfunction isExpired(\n  initialTime,\n  expiry,\n  targetTime = +new Date(),\n) {\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\n/**\n * Checks to see if session is expired\n */\nfunction isSessionExpired(\n  session,\n  {\n    maxReplayDuration,\n    sessionIdleExpire,\n    targetTime = Date.now(),\n  },\n) {\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\n/** If the session should be refreshed or not. */\nfunction shouldRefreshSession(\n  session,\n  { sessionIdleExpire, maxReplayDuration },\n) {\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\n/**\n * Get or create a session, when initializing the replay.\n * Returns a session that may be unsampled.\n */\nfunction loadOrCreateSession(\n  {\n    sessionIdleExpire,\n    maxReplayDuration,\n    previousSessionId,\n  }\n\n,\n  sessionOptions,\n) {\n  const existingSession = sessionOptions.stickySession && fetchSession();\n\n  // No session exists yet, just create a new one\n  if (!existingSession) {\n    DEBUG_BUILD && logger.infoTick('Creating new session');\n    return createSession(sessionOptions, { previousSessionId });\n  }\n\n  if (!shouldRefreshSession(existingSession, { sessionIdleExpire, maxReplayDuration })) {\n    return existingSession;\n  }\n\n  DEBUG_BUILD && logger.infoTick('Session in sessionStorage is expired, creating new one...');\n  return createSession(sessionOptions, { previousSessionId: existingSession.id });\n}\n\nfunction isCustomEvent(event) {\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 */\nfunction addEventSync(replay, event, isCheckout) {\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 */\nfunction addEvent(\n  replay,\n  event,\n  isCheckout,\n) {\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,\n  event,\n  isCheckout,\n) {\n  const { eventBuffer } = replay;\n\n  if (!eventBuffer || (eventBuffer.waitForCheckout && !isCheckout)) {\n    return null;\n  }\n\n  const isBufferMode = replay.recordingMode === 'buffer';\n\n  try {\n    if (isCheckout && isBufferMode) {\n      eventBuffer.clear();\n    }\n\n    if (isCheckout) {\n      eventBuffer.hasCheckout = true;\n      eventBuffer.waitForCheckout = false;\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 eventBuffer.addEvent(eventAfterPossibleCallback);\n  } catch (error) {\n    const isExceeded = error && error instanceof EventBufferSizeExceededError;\n    const reason = isExceeded ? 'addEventSizeExceeded' : 'addEvent';\n\n    if (isExceeded && isBufferMode) {\n      // Clear buffer and wait for next checkout\n      eventBuffer.clear();\n      eventBuffer.waitForCheckout = true;\n\n      return null;\n    }\n\n    replay.handleException(error);\n\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. */\nfunction shouldAddEvent(replay, event) {\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    DEBUG_BUILD &&\n      logger.infoTick(`Skipping event with timestamp ${timestampInMs} because it is after maxReplayDuration`);\n    return false;\n  }\n\n  return true;\n}\n\nfunction maybeApplyCallback(\n  event,\n  callback,\n) {\n  try {\n    if (typeof callback === 'function' && isCustomEvent(event)) {\n      return callback(event);\n    }\n  } catch (error) {\n    DEBUG_BUILD &&\n      logger.exception(error, 'An error occurred in the `beforeAddRecordingEvent` callback, skipping the event...');\n    return null;\n  }\n\n  return event;\n}\n\n/** If the event is an error event */\nfunction isErrorEvent(event) {\n  return !event.type;\n}\n\n/** If the event is a transaction event */\nfunction isTransactionEvent(event) {\n  return event.type === 'transaction';\n}\n\n/** If the event is an replay event */\nfunction isReplayEvent(event) {\n  return event.type === 'replay_event';\n}\n\n/** If the event is a feedback event */\nfunction isFeedbackEvent(event) {\n  return event.type === 'feedback';\n}\n\n/**\n * Returns a listener to be added to `client.on('afterSendErrorEvent, listener)`.\n */\nfunction handleAfterSendEvent(replay) {\n  return (event, sendResponse) => {\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 (!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, event) {\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 );\n  }\n}\n\nfunction handleErrorEvent(replay, event) {\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$3(async () => {\n    try {\n      // Capture current event buffer as new replay\n      await replay.sendBufferedReplayOrFlush();\n    } catch (err) {\n      replay.handleException(err);\n    }\n  });\n}\n\n/**\n * Returns a listener to be added to `client.on('afterSendErrorEvent, listener)`.\n */\nfunction handleBeforeSendEvent(replay) {\n  return (event) => {\n    if (!replay.isEnabled() || !isErrorEvent(event)) {\n      return;\n    }\n\n    handleHydrationError(replay, event);\n  };\n}\n\nfunction handleHydrationError(replay, event) {\n  const exceptionValue =\n    event.exception && event.exception.values && event.exception.values[0] && 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    // With newer React versions, the messages changed to a different website https://react.dev/errors/418\n    exceptionValue.match(\n      /(reactjs\\.org\\/docs\\/error-decoder\\.html\\?invariant=|react\\.dev\\/errors\\/)(418|419|422|423|425)/,\n    ) ||\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      data: {\n        url: getLocationHref(),\n      },\n    });\n    addBreadcrumbEvent(replay, breadcrumb);\n  }\n}\n\n/**\n * Handle breadcrumbs that Sentry captures, and make sure to capture relevant breadcrumbs to Replay as well.\n */\nfunction handleBreadcrumbs(replay) {\n  const client = getClient();\n\n  if (!client) {\n    return;\n  }\n\n  client.on('beforeAddBreadcrumb', breadcrumb => beforeAddBreadcrumb(replay, breadcrumb));\n}\n\nfunction beforeAddBreadcrumb(replay, breadcrumb) {\n  if (!replay.isEnabled() || !isBreadcrumbWithCategory(breadcrumb)) {\n    return;\n  }\n\n  const result = normalizeBreadcrumb(breadcrumb);\n  if (result) {\n    addBreadcrumbEvent(replay, result);\n  }\n}\n\n/** Exported only for tests. */\nfunction normalizeBreadcrumb(breadcrumb) {\n  if (\n    !isBreadcrumbWithCategory(breadcrumb) ||\n    [\n      // fetch & xhr are handled separately,in handleNetworkBreadcrumbs\n      'fetch',\n      'xhr',\n      // These two are breadcrumbs for emitted sentry events, we don't care about them\n      'sentry.event',\n      'sentry.transaction',\n    ].includes(breadcrumb.category) ||\n    // We capture UI breadcrumbs separately\n    breadcrumb.category.startsWith('ui.')\n  ) {\n    return null;\n  }\n\n  if (breadcrumb.category === 'console') {\n    return normalizeConsoleBreadcrumb(breadcrumb);\n  }\n\n  return createBreadcrumb(breadcrumb);\n}\n\n/** exported for tests only */\nfunction normalizeConsoleBreadcrumb(\n  breadcrumb,\n) {\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 (e) {\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\nfunction isBreadcrumbWithCategory(breadcrumb) {\n  return !!breadcrumb.category;\n}\n\n/**\n * Returns true if we think the given event is an error originating inside of rrweb.\n */\nfunction isRrwebError(event, hint) {\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\n/**\n * Reset the `replay_id` field on the DSC.\n */\nfunction resetReplayIdOnDynamicSamplingContext() {\n  // Reset DSC on the current scope, if there is one\n  const dsc = getCurrentScope().getPropagationContext().dsc;\n  if (dsc) {\n    delete dsc.replay_id;\n  }\n\n  // Clear it from frozen DSC on the active span\n  const activeSpan = getActiveSpan();\n  if (activeSpan) {\n    const dsc = getDynamicSamplingContextFromSpan(activeSpan);\n    delete (dsc ).replay_id;\n  }\n}\n\n/**\n * Add a feedback breadcrumb event to replay.\n */\nfunction addFeedbackBreadcrumb(replay, event) {\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    } );\n\n    return false;\n  });\n}\n\n/**\n * Determine if event should be sampled (only applies in buffer mode).\n * When an event is captured by `handleGlobalEvent`, when in buffer mode\n * we determine if we want to sample the error or not.\n */\nfunction shouldSampleForBufferEvent(replay, event) {\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\n/**\n * Returns a listener to be added to `addEventProcessor(listener)`.\n */\nfunction handleGlobalEventListener(replay) {\n  return Object.assign(\n    (event, hint) => {\n      // Do nothing if replay has been disabled or paused\n      if (!replay.isEnabled() || replay.isPaused()) {\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        // prevent exceeding replay durations by removing the expired replayId from the DSC\n        resetReplayIdOnDynamicSamplingContext();\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('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      return event;\n    },\n    { id: 'Replay' },\n  );\n}\n\n/**\n * Create a \"span\" for each performance entry.\n */\nfunction createPerformanceSpans(\n  replay,\n  entries,\n) {\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\nfunction handleHistory(handlerData) {\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 */\nfunction handleHistorySpanListener(replay) {\n  return (handlerData) => {\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\n/**\n * Check whether a given request URL should be filtered out. This is so we\n * don't log Sentry ingest requests.\n */\nfunction shouldFilterRequest(replay, url) {\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\n/** Add a performance entry breadcrumb */\nfunction addNetworkBreadcrumb(\n  replay,\n  result,\n) {\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\n/** Get the size of a body. */\nfunction getBodySize(body) {\n  if (!body) {\n    return undefined;\n  }\n\n  const textEncoder = new TextEncoder();\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 (e) {\n    // just return undefined\n  }\n\n  return undefined;\n}\n\n/** Convert a Content-Length header to number/undefined.  */\nfunction parseContentLengthHeader(header) {\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. */\nfunction getBodyString(body) {\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 (error) {\n    DEBUG_BUILD && logger.exception(error, 'Failed to serialize body', body);\n    return [undefined, 'BODY_PARSE_ERROR'];\n  }\n\n  DEBUG_BUILD && logger.info('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. */\nfunction mergeWarning(\n  info,\n  warning,\n) {\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. */\nfunction makeNetworkReplayBreadcrumb(\n  type,\n  data,\n) {\n  if (!data) {\n    return null;\n  }\n\n  const { startTimestamp, endTimestamp, url, method, statusCode, request, response } = data;\n\n  const result = {\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. */\nfunction buildSkippedNetworkRequestOrResponse(bodySize) {\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. */\nfunction buildNetworkRequestOrResponse(\n  headers,\n  bodySize,\n  body,\n) {\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 = {\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 */\nfunction getAllowedHeaders(headers, allowedHeaders) {\n  return Object.entries(headers).reduce((filteredHeaders, [key, value]) => {\n    const normalizedKey = key.toLowerCase();\n    // Avoid putting empty strings into the headers\n    if (allowedHeaders.includes(normalizedKey) && headers[key]) {\n      filteredHeaders[normalizedKey] = value;\n    }\n    return filteredHeaders;\n  }, {});\n}\n\nfunction _serializeFormData(formData) {\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)\n\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 (e2) {\n      // fall back to just send the body as string\n    }\n  }\n\n  return {\n    body,\n  };\n}\n\nfunction _strIsProbablyJson(str) {\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. */\nfunction urlMatches(url, urls) {\n  const fullUrl = getFullUrl(url);\n\n  return stringMatchesSomePattern(fullUrl, urls);\n}\n\n/** exported for tests */\nfunction getFullUrl(url, baseURI = WINDOW.document.baseURI) {\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\n/**\n * Capture a fetch breadcrumb to a replay.\n * This adds additional data (where appropriate).\n */\nasync function captureFetchBreadcrumbToReplay(\n  breadcrumb,\n  hint,\n  options\n\n,\n) {\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.exception(error, 'Failed to capture fetch breadcrumb');\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 */\nfunction enrichFetchBreadcrumb(\n  breadcrumb,\n  hint,\n) {\n  const { input, response } = hint;\n\n  const body = input ? _getFetchRequestArgBody(input) : undefined;\n  const reqSize = getBodySize(body);\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,\n  hint,\n  options,\n) {\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 },\n  input,\n  requestBodySize,\n) {\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. */\nasync function _getResponseInfo(\n  captureDetails,\n  {\n    networkCaptureBodies,\n    networkResponseHeaders,\n  },\n  response,\n  responseBodySize,\n) {\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\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,\n  {\n    networkCaptureBodies,\n    responseBodySize,\n    captureDetails,\n    headers,\n  }\n\n,\n) {\n  try {\n    const size =\n      bodyText && bodyText.length && responseBodySize === undefined ? getBodySize(bodyText) : 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.exception(error, 'Failed to serialize response body');\n    // fallback\n    return buildNetworkRequestOrResponse(headers, responseBodySize, undefined);\n  }\n}\n\nasync function _parseFetchResponseBody(response) {\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    if (error instanceof Error && error.message.indexOf('Timeout') > -1) {\n      DEBUG_BUILD && logger.warn('Parsing text body from response timed out');\n      return [undefined, 'BODY_PARSE_TIMEOUT'];\n    }\n\n    DEBUG_BUILD && logger.exception(error, 'Failed to get text body from response');\n    return [undefined, 'BODY_PARSE_ERROR'];\n  }\n}\n\nfunction _getFetchRequestArgBody(fetchArgs = []) {\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] ).body;\n}\n\nfunction getAllHeaders(headers, allowedHeaders) {\n  const allHeaders = {};\n\n  allowedHeaders.forEach(header => {\n    if (headers.get(header)) {\n      allHeaders[header] = headers.get(header) ;\n    }\n  });\n\n  return allHeaders;\n}\n\nfunction getRequestHeaders(fetchArgs, allowedHeaders) {\n  if (fetchArgs.length === 1 && typeof fetchArgs[0] !== 'string') {\n    return getHeadersFromOptions(fetchArgs[0] , allowedHeaders);\n  }\n\n  if (fetchArgs.length === 2) {\n    return getHeadersFromOptions(fetchArgs[1] , allowedHeaders);\n  }\n\n  return {};\n}\n\nfunction getHeadersFromOptions(\n  input,\n  allowedHeaders,\n) {\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) {\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.exception(error, 'Failed to clone response body');\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) {\n  return new Promise((resolve, reject) => {\n    const timeout = setTimeout$3(() => 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\nasync function _getResponseText(response) {\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\n/**\n * Capture an XHR breadcrumb to a replay.\n * This adds additional data (where appropriate).\n */\nasync function captureXhrBreadcrumbToReplay(\n  breadcrumb,\n  hint,\n  options,\n) {\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.exception(error, 'Failed to capture xhr breadcrumb');\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 */\nfunction enrichXhrBreadcrumb(\n  breadcrumb,\n  hint,\n) {\n  const { xhr, input } = hint;\n\n  if (!xhr) {\n    return;\n  }\n\n  const reqSize = getBodySize(input);\n  const resSize = xhr.getResponseHeader('content-length')\n    ? parseContentLengthHeader(xhr.getResponseHeader('content-length'))\n    : _getBodySize(xhr.response, xhr.responseType);\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,\n  hint,\n  options,\n) {\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) {\n  const headers = xhr.getAllResponseHeaders();\n\n  if (!headers) {\n    return {};\n  }\n\n  return headers.split('\\r\\n').reduce((acc, line) => {\n    const [key, value] = line.split(': ') ;\n    if (value) {\n      acc[key.toLowerCase()] = value;\n    }\n    return acc;\n  }, {});\n}\n\nfunction _getXhrResponseBody(xhr) {\n  // We collect errors that happen, but only log them if we can't get any response body\n  const errors = [];\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('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 */\nfunction _parseXhrResponse(\n  body,\n  responseType,\n) {\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 (error) {\n    DEBUG_BUILD && logger.exception(error, 'Failed to serialize body', body);\n    return [undefined, 'BODY_PARSE_ERROR'];\n  }\n\n  DEBUG_BUILD && logger.info('Skipping network body because of body type', body);\n\n  return [undefined, 'UNPARSEABLE_BODY_TYPE'];\n}\n\nfunction _getBodySize(\n  body,\n  responseType,\n) {\n  try {\n    const bodyStr = responseType === 'json' && body && typeof body === 'object' ? JSON.stringify(body) : body;\n    return getBodySize(bodyStr);\n  } catch (e2) {\n    return undefined;\n  }\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 */\nfunction handleNetworkBreadcrumbs(replay) {\n  const client = getClient();\n\n  try {\n    const {\n      networkDetailAllowUrls,\n      networkDetailDenyUrls,\n      networkCaptureBodies,\n      networkRequestHeaders,\n      networkResponseHeaders,\n    } = replay.getOptions();\n\n    const options = {\n      replay,\n      networkDetailAllowUrls,\n      networkDetailDenyUrls,\n      networkCaptureBodies,\n      networkRequestHeaders,\n      networkResponseHeaders,\n    };\n\n    if (client) {\n      client.on('beforeAddBreadcrumb', (breadcrumb, hint) => beforeAddNetworkBreadcrumb(options, breadcrumb, hint));\n    }\n  } catch (e2) {\n    // Do nothing\n  }\n}\n\n/** just exported for tests */\nfunction beforeAddNetworkBreadcrumb(\n  options,\n  breadcrumb,\n  hint,\n) {\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);\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);\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.exception(e, 'Error when enriching network breadcrumb');\n  }\n}\n\nfunction _isXhrBreadcrumb(breadcrumb) {\n  return breadcrumb.category === 'xhr';\n}\n\nfunction _isFetchBreadcrumb(breadcrumb) {\n  return breadcrumb.category === 'fetch';\n}\n\nfunction _isXhrHint(hint) {\n  return hint && hint.xhr;\n}\n\nfunction _isFetchHint(hint) {\n  return hint && hint.response;\n}\n\n/**\n * Add global listeners that cannot be removed.\n */\nfunction addGlobalListeners(replay) {\n  // Listeners from core SDK //\n  const client = getClient();\n\n  addClickKeypressInstrumentationHandler(handleDomListener(replay));\n  addHistoryInstrumentationHandler(handleHistorySpanListener(replay));\n  handleBreadcrumbs(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);\n  addEventProcessor(eventProcessor);\n\n  // If a custom client has no hooks yet, we continue to use the \"old\" implementation\n  if (client) {\n    client.on('beforeSendEvent', handleBeforeSendEvent(replay));\n    client.on('afterSendEvent', handleAfterSendEvent(replay));\n    client.on('createDsc', (dsc) => {\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('spanStart', span => {\n      replay.lastActiveSpan = span;\n    });\n\n    // We may be missing the initial spanStart due to timing issues,\n    // so we capture it on finish again.\n    client.on('spanEnd', span => {\n      replay.lastActiveSpan = span;\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/**\n * Create a \"span\" for the total amount of memory being used by JS objects\n * (including v8 internal objects).\n */\nasync function addMemoryEntry(replay) {\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) {\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\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 */\nfunction debounce(func, wait, options) {\n  let callbackReturnValue;\n\n  let timerId;\n  let maxTimerId;\n\n  const maxWait = options && options.maxWait ? Math.max(options.maxWait, wait) : 0;\n\n  function invokeFunc() {\n    cancelTimers();\n    callbackReturnValue = func();\n    return callbackReturnValue;\n  }\n\n  function cancelTimers() {\n    timerId !== undefined && clearTimeout(timerId);\n    maxTimerId !== undefined && clearTimeout(maxTimerId);\n    timerId = maxTimerId = undefined;\n  }\n\n  function flush() {\n    if (timerId !== undefined || maxTimerId !== undefined) {\n      return invokeFunc();\n    }\n    return callbackReturnValue;\n  }\n\n  function debounced() {\n    if (timerId) {\n      clearTimeout(timerId);\n    }\n    timerId = setTimeout$3(invokeFunc, wait);\n\n    if (maxWait && maxTimerId === undefined) {\n      maxTimerId = setTimeout$3(invokeFunc, maxWait);\n    }\n\n    return callbackReturnValue;\n  }\n\n  debounced.cancel = cancelTimers;\n  debounced.flush = flush;\n  return debounced;\n}\n\nconst NAVIGATOR = GLOBAL_OBJ.navigator;\n\n/**\n *  Disable sampling mousemove events on iOS browsers as this can cause blocking the main thread\n *  https://github.com/getsentry/sentry-javascript/issues/14534\n */\nfunction getRecordingSamplingOptions() {\n  if (\n    /iPhone|iPad|iPod/i.test((NAVIGATOR && NAVIGATOR.userAgent) || '') ||\n    (/Macintosh/i.test((NAVIGATOR && NAVIGATOR.userAgent) || '') &&\n      NAVIGATOR &&\n      NAVIGATOR.maxTouchPoints &&\n      NAVIGATOR.maxTouchPoints > 1)\n  ) {\n    return {\n      sampling: {\n        mousemove: false,\n      },\n    };\n  }\n\n  return {};\n}\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 */\nfunction getHandleRecordingEmit(replay) {\n  let hadFirstEvent = false;\n\n  return (event, _isCheckout) => {\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('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      const session = replay.session;\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. We have an experimental mode\n      // to perform multiple checkouts a session (the idea is to improve\n      // seeking during playback), so also only include if segmentId is 0\n      // (handled in `addSettingsEvent`).\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      // 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' && session && replay.eventBuffer) {\n        const earliestEvent = replay.eventBuffer.getEarliestTimestamp();\n        if (earliestEvent) {\n          DEBUG_BUILD &&\n            logger.info(`Updating session start time to earliest event in buffer to ${new Date(earliestEvent)}`);\n\n          session.started = earliestEvent;\n\n          if (replay.getOptions().stickySession) {\n            saveSession(session);\n          }\n        }\n      }\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 (session && session.previousSessionId) {\n        return true;\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 */\nfunction createOptionsEvent(replay) {\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, isCheckout) {\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\n/**\n * Create a replay envelope ready to be sent.\n * This includes both the replay event, as well as the recording data.\n */\nfunction createReplayEnvelope(\n  replayEvent,\n  recordingData,\n  dsn,\n  tunnel,\n) {\n  return createEnvelope(\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\n/**\n * Prepare the recording data ready to be sent.\n */\nfunction prepareRecordingData({\n  recordingData,\n  headers,\n}\n\n) {\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\n/**\n * Prepare a replay event & enrich it with the SDK metadata.\n */\nasync function prepareReplayEvent({\n  client,\n  scope,\n  replayId: event_id,\n  event,\n}\n\n) {\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 = { event_id, integrations };\n\n  client.emit('preprocessEvent', event, eventHint);\n\n  const preparedEvent = (await prepareEvent(\n    client.getOptions(),\n    event,\n    eventHint,\n    scope,\n    client,\n    getIsolationScope(),\n  )) ;\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();\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\n/**\n * Send replay attachment using `fetch()`\n */\nasync function sendReplayRequest({\n  recordingData,\n  replayId,\n  segmentId: segment_id,\n  eventContext,\n  timestamp,\n  session,\n}) {\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 resolvedSyncPromise({});\n  }\n\n  const baseEvent = {\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    DEBUG_BUILD && logger.info('An event processor returned `null`, will not send event.');\n    return resolvedSyncPromise({});\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;\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 (e) {\n      // nothing to do\n    }\n    throw error;\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 */\nclass TransportStatusCodeError extends Error {\n   constructor(statusCode) {\n    super(`Transport returned status code ${statusCode}`);\n  }\n}\n\n/**\n * This error indicates that we hit a rate limit API error.\n */\nclass RateLimitError extends Error {\n\n   constructor(rateLimits) {\n    super('Rate limit hit');\n    this.rateLimits = rateLimits;\n  }\n}\n\n/**\n * Finalize and send the current replay event to Sentry\n */\nasync function sendReplay(\n  replayData,\n  retryConfig = {\n    count: 0,\n    interval: RETRY_BASE_INTERVAL,\n  },\n) {\n  const { recordingData, onError } = 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 (onError) {\n      onError(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 (e) {\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$3(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\nconst THROTTLED = '__THROTTLED';\nconst 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\nfunction throttle(\n  fn,\n  maxCount,\n  durationSeconds,\n) {\n  const counter = new Map();\n\n  const _cleanup = (now) => {\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 = () => {\n    return [...counter.values()].reduce((a, b) => a + b, 0);\n  };\n\n  let isThrottled = false;\n\n  return (...rest) => {\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\n/* eslint-disable max-lines */ // TODO: We might want to split this file up\n\n/**\n * The main replay container class, which holds all the state and methods for recording and sending replays.\n */\nclass ReplayContainer  {\n\n  /**\n   * Recording can happen in one of two 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\n  /**\n   * The current or last active span.\n   * This is only available when performance is enabled.\n   */\n\n  /**\n   * These are here so we can overwrite them in tests etc.\n   * @hidden\n   */\n\n  /** The replay has to be manually started, because no sample rate (neither session or error) was provided. */\n\n  /**\n   * Options to pass to `rrweb.record()`\n   */\n\n  /**\n   * Timestamp of the last user activity. This lives across sessions.\n   */\n\n  /**\n   * Is the integration currently active?\n   */\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\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\n  /**\n   * Function to stop recording\n   */\n\n  /**\n   * Internal use for canvas recording options\n   */\n\n   constructor({\n    options,\n    recordingOptions,\n  }\n\n) {ReplayContainer.prototype.__init.call(this);ReplayContainer.prototype.__init2.call(this);ReplayContainer.prototype.__init3.call(this);ReplayContainer.prototype.__init4.call(this);ReplayContainer.prototype.__init5.call(this);ReplayContainer.prototype.__init6.call(this);\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    } ;\n    this._lastActivity = Date.now();\n    this._isEnabled = false;\n    this._isPaused = false;\n    this._requiresManualStart = 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, isCheckout) => 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 = 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    // Configure replay logger w/ experimental options\n    if (DEBUG_BUILD) {\n      const experiments = options._experiments;\n      logger.setConfig({\n        captureExceptions: !!experiments.captureExceptions,\n        traceInternals: !!experiments.traceInternals,\n      });\n    }\n  }\n\n  /** Get the event context. */\n   getContext() {\n    return this._context;\n  }\n\n  /** If recording is currently enabled. */\n   isEnabled() {\n    return this._isEnabled;\n  }\n\n  /** If recording is currently paused. */\n   isPaused() {\n    return this._isPaused;\n  }\n\n  /**\n   * Determine if canvas recording is enabled\n   */\n   isRecordingCanvas() {\n    return Boolean(this._canvas);\n  }\n\n  /** Get the replay integration options. */\n   getOptions() {\n    return this._options;\n  }\n\n  /** A wrapper to conditionally capture exceptions. */\n   handleException(error) {\n    DEBUG_BUILD && logger.exception(error);\n    if (this._options.onError) {\n      this._options.onError(error);\n    }\n  }\n\n  /**\n   * Initializes the plugin based on sampling configuration. Should not be\n   * called outside of constructor.\n   */\n   initializeSampling(previousSessionId) {\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    const requiresManualStart = errorSampleRate <= 0 && sessionSampleRate <= 0;\n\n    this._requiresManualStart = requiresManualStart;\n\n    if (requiresManualStart) {\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      DEBUG_BUILD && logger.exception(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    DEBUG_BUILD && logger.infoTick(`Starting replay in ${this.recordingMode} mode`);\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 log a message 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   start() {\n    if (this._isEnabled && this.recordingMode === 'session') {\n      DEBUG_BUILD && logger.info('Recording is already in progress');\n      return;\n    }\n\n    if (this._isEnabled && this.recordingMode === 'buffer') {\n      DEBUG_BUILD && logger.info('Buffering is in progress, call `flush()` to save the replay');\n      return;\n    }\n\n    DEBUG_BUILD && logger.infoTick('Starting replay in session mode');\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      },\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   startBuffering() {\n    if (this._isEnabled) {\n      DEBUG_BUILD && logger.info('Buffering is in progress, call `flush()` to save the replay');\n      return;\n    }\n\n    DEBUG_BUILD && logger.infoTick('Starting replay in buffer mode');\n\n    const session = loadOrCreateSession(\n      {\n        sessionIdleExpire: this.timeouts.sessionIdleExpire,\n        maxReplayDuration: this._options.maxReplayDuration,\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   startRecording() {\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'\n          ? { checkoutEveryNms: BUFFER_CHECKOUT_TIME }\n          : // Otherwise, use experimental option w/ min checkout time of 6 minutes\n            // This is to improve playback seeking as there could potentially be\n            // less mutations to process in the worse cases.\n            //\n            // checkout by \"N\" events is probably ideal, but means we have less\n            // control about the number of checkouts we make (which generally\n            // increases replay size)\n            this._options._experiments.continuousCheckout && {\n              // Minimum checkout time is 6 minutes\n              checkoutEveryNms: Math.max(360000, this._options._experiments.continuousCheckout),\n            }),\n        emit: getHandleRecordingEmit(this),\n        ...getRecordingSamplingOptions(),\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   stopRecording() {\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   async stop({ forceFlush = false, reason } = {}) {\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      DEBUG_BUILD && logger.info(`Stopping Replay${reason ? ` triggered by ${reason}` : ''}`);\n\n      resetReplayIdOnDynamicSamplingContext();\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   pause() {\n    if (this._isPaused) {\n      return;\n    }\n\n    this._isPaused = true;\n    this.stopRecording();\n\n    DEBUG_BUILD && logger.info('Pausing replay');\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   resume() {\n    if (!this._isPaused || !this._checkSession()) {\n      return;\n    }\n\n    this._isPaused = false;\n    this.startRecording();\n\n    DEBUG_BUILD && logger.info('Resuming replay');\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   async sendBufferedReplayOrFlush({ continueRecording = true } = {}) {\n    if (this.recordingMode === 'session') {\n      return this.flushImmediate();\n    }\n\n    const activityTime = Date.now();\n\n    DEBUG_BUILD && logger.info('Converting buffer to session');\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 ) === '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   addUpdate(cb) {\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   triggerUserActivity() {\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   updateUserActivity() {\n    this._updateUserActivity();\n    this._updateSessionActivity();\n  }\n\n  /**\n   * Only flush if `this.recordingMode === 'session'`\n   */\n   conditionalFlush() {\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   flush() {\n    return this._debouncedFlush() ;\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 multiple flushes happening closely together.\n   */\n   flushImmediate() {\n    this._debouncedFlush();\n    // `.flush` is provided by the debounced function, analogously to lodash.debounce\n    return this._debouncedFlush.flush() ;\n  }\n\n  /**\n   * Cancels queued up flushes.\n   */\n   cancelFlush() {\n    this._debouncedFlush.cancel();\n  }\n\n  /** Get the current session (=replay) ID */\n   getSessionId() {\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   checkAndHandleExpiredSession() {\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   setInitialState() {\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   throttledAddEvent(\n    event,\n    isCheckout,\n  ) {\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   getCurrentRoute() {\n    const lastActiveSpan = this.lastActiveSpan || getActiveSpan();\n    const lastRootSpan = lastActiveSpan && getRootSpan(lastActiveSpan);\n\n    const attributes = (lastRootSpan && spanToJSON(lastRootSpan).data) || {};\n    const source = attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];\n    if (!lastRootSpan || !source || !['route', 'custom'].includes(source)) {\n      return undefined;\n    }\n\n    return spanToJSON(lastRootSpan).description;\n  }\n\n  /**\n   * Initialize and start all listeners to varying events (DOM,\n   * Performance Observer, Recording, Sentry SDK, etc)\n   */\n   _initializeRecording() {\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  /**\n   * Loads (or refreshes) the current session.\n   */\n   _initializeSessionForSampling(previousSessionId) {\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        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   _checkSession() {\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   async _refreshSession(session) {\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   _addListeners() {\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   _removeListeners() {\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   __init() {this._handleVisibilityChange = () => {\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   __init2() {this._handleWindowBlur = () => {\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   __init3() {this._handleWindowFocus = () => {\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   __init4() {this._handleKeyboardEvent = (event) => {\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   _doChangeToBackgroundTasks(breadcrumb) {\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   _doChangeToForegroundTasks(breadcrumb) {\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      DEBUG_BUILD && logger.info('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   _updateUserActivity(_lastActivity = Date.now()) {\n    this._lastActivity = _lastActivity;\n  }\n\n  /**\n   * Updates the session's last activity timestamp\n   */\n   _updateSessionActivity(_lastActivity = Date.now()) {\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   _createCustomBreadcrumb(breadcrumb) {\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   _addPerformanceEntries() {\n    let performanceEntries = createPerformanceEntries(this.performanceEntries).concat(this.replayPerformanceEntries);\n\n    this.performanceEntries = [];\n    this.replayPerformanceEntries = [];\n\n    // If we are manually starting, we want to ensure we only include performance entries\n    // that are after the initial timestamp\n    // The reason for this is that we may have performance entries from the page load, but may decide to start\n    // the replay later on, in which case we do not want to include these entries.\n    // without this, manually started replays can have events long before the actual replay recording starts,\n    // which messes with the timeline etc.\n    if (this._requiresManualStart) {\n      const initialTimestampInSeconds = this._context.initialTimestamp / 1000;\n      performanceEntries = performanceEntries.filter(entry => entry.start >= initialTimestampInSeconds);\n    }\n\n    return Promise.all(createPerformanceSpans(this, performanceEntries));\n  }\n\n  /**\n   * Clear _context\n   */\n   _clearContext() {\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   _updateInitialTimestampFromEventBuffer() {\n    const { session, eventBuffer } = this;\n    // If replay was started manually (=no sample rate was given),\n    // We do not want to back-port the initial timestamp\n    if (!session || !eventBuffer || this._requiresManualStart) {\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   _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   async _runFlush() {\n    const replayId = this.getSessionId();\n\n    if (!this.session || !this.eventBuffer || !replayId) {\n      DEBUG_BUILD && logger.error('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 accommodate 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 + 30000) {\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        timestamp,\n        onError: err => this.handleException(err),\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        const dropReason = err instanceof RateLimitError ? 'ratelimit_backoff' : 'send_error';\n        client.recordDroppedEvent(dropReason, '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   __init5() {this._flush = async ({\n    force = false,\n  }\n\n = {}) => {\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('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 + 5000;\n    if (tooShort || tooLong) {\n      DEBUG_BUILD &&\n        logger.info(\n          `Session duration (${Math.floor(duration / 1000)}s) is too ${\n            tooShort ? 'short' : 'long'\n          }, not sending replay.`,\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      DEBUG_BUILD && logger.info('Flushing initial segment without checkout.');\n      // TODO FN: Evaluate if we want to stop here, or remove this again?\n    }\n\n    const _flushInProgress = !!this._flushLock;\n\n    // this._flushLock acts as a lock so that future calls to `_flush()` will\n    // be blocked until current flush is finished (i.e. this promise resolves)\n    if (!this._flushLock) {\n      this._flushLock = this._runFlush();\n    }\n\n    try {\n      await this._flushLock;\n    } catch (err) {\n      this.handleException(err);\n    } finally {\n      this._flushLock = undefined;\n\n      if (_flushInProgress) {\n        // Wait for previous flush to finish, then call the debounced\n        // `_flush()`. It's possible there are other flush requests queued and\n        // waiting for it to resolve. We want to reduce all outstanding\n        // requests (as well as any new flush requests that occur within a\n        // second of the locked flush completing) into a single flush.\n        this._debouncedFlush();\n      }\n    }\n  };}\n\n  /** Save the session, if it is sticky */\n   _maybeSaveSession() {\n    if (this.session && this._options.stickySession) {\n      saveSession(this.session);\n    }\n  }\n\n  /** Handler for rrweb.record.onMutation */\n   __init6() {this._onMutationHandler = (mutations) => {\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\nfunction getOption(selectors, defaultSelectors) {\n  return [\n    ...selectors,\n    // sentry defaults\n    ...defaultSelectors,\n  ].join(',');\n}\n\n/**\n * Returns privacy related configuration for use in rrweb\n */\nfunction getPrivacyOptions({ mask, unmask, block, unblock, ignore }) {\n  const defaultBlockedElements = ['base', 'iframe[srcdoc]:not([src])'];\n\n  const maskSelector = getOption(mask, ['.sentry-mask', '[data-sentry-mask]']);\n  const unmaskSelector = getOption(unmask, []);\n\n  const options = {\n    // We are making the decision to make text and input selectors the same\n    maskTextSelector: maskSelector,\n    unmaskTextSelector: unmaskSelector,\n\n    blockSelector: getOption(block, ['.sentry-block', '[data-sentry-block]', ...defaultBlockedElements]),\n    unblockSelector: getOption(unblock, []),\n    ignoreSelector: getOption(ignore, ['.sentry-ignore', '[data-sentry-ignore]', 'input[type=\"file\"]']),\n  };\n\n  return options;\n}\n\n/**\n * Masks an attribute if necessary, otherwise return attribute value as-is.\n */\nfunction maskAttribute({\n  el,\n  key,\n  maskAttributes,\n  maskAllText,\n  privacyOptions,\n  value,\n}) {\n  // We only mask attributes if `maskAllText` is true\n  if (!maskAllText) {\n    return value;\n  }\n\n  // unmaskTextSelector takes precedence\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\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\n/**\n * Sentry integration for [Session Replay](https://sentry.io/for/session-replay/).\n *\n * See the [Replay documentation](https://docs.sentry.io/platforms/javascript/guides/session-replay/) for more information.\n *\n * @example\n *\n * ```\n * Sentry.init({\n *   dsn: '__DSN__',\n *   integrations: [Sentry.replayIntegration()],\n * });\n * ```\n */\nconst replayIntegration = ((options) => {\n  return new Replay(options);\n}) ;\n\n/**\n * Replay integration\n *\n * TODO: Rewrite this to be functional integration\n * Exported for tests.\n */\nclass Replay  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'Replay';}\n\n  /**\n   * @inheritDoc\n   */\n\n  /**\n   * Options to pass to `rrweb.record()`\n   */\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\n   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    maskAllText = true,\n    maskAllInputs = true,\n    blockAllMedia = true,\n\n    mutationBreadcrumbLimit = 750,\n    mutationLimit = 10000,\n\n    slowClickTimeout = 7000,\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    onError,\n  } = {}) {\n    this.name = Replay.id;\n\n    const privacyOptions = getPrivacyOptions({\n      mask,\n      unmask,\n      block,\n      unblock,\n      ignore,\n    });\n\n    this._recordingOptions = {\n      maskAllInputs,\n      maskAllText,\n      maskInputOptions: { password: true },\n      maskTextFn: maskFn,\n      maskInputFn: maskFn,\n      maskAttributeFn: (key, value, el) =>\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) => {\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      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      onError,\n\n      _experiments,\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   get _isInitialized() {\n    return _initialized;\n  }\n\n  /** Update _isInitialized */\n   set _isInitialized(value) {\n    _initialized = value;\n  }\n\n  /**\n   * Setup and initialize replay container\n   */\n   afterAllSetup(client) {\n    if (!isBrowser() || this._replay) {\n      return;\n    }\n\n    this._setup(client);\n    this._initialize(client);\n  }\n\n  /**\n   * Start a replay regardless of sampling rate. Calling this will always\n   * create a new session. Will log a message 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   start() {\n    if (!this._replay) {\n      return;\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   startBuffering() {\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   stop() {\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   * If replay is not enabled, a new session replay is started.\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   flush(options) {\n    if (!this._replay) {\n      return Promise.resolve();\n    }\n\n    // assuming a session should be recorded in this case\n    if (!this._replay.isEnabled()) {\n      this._replay.start();\n      return Promise.resolve();\n    }\n\n    return this._replay.sendBufferedReplayOrFlush(options);\n  }\n\n  /**\n   * Get the current session ID.\n   */\n   getReplayId() {\n    if (!this._replay || !this._replay.isEnabled()) {\n      return;\n    }\n\n    return this._replay.getSessionId();\n  }\n\n  /**\n   * Get the current recording mode. This can be either `session` or `buffer`.\n   *\n   * `session`: Recording the whole session, sending it continuously\n   * `buffer`: Always keeping 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   getRecordingMode() {\n    if (!this._replay || !this._replay.isEnabled()) {\n      return;\n    }\n\n    return this._replay.recordingMode;\n  }\n\n  /**\n   * Initializes replay.\n   */\n   _initialize(client) {\n    if (!this._replay) {\n      return;\n    }\n\n    this._maybeLoadFromReplayCanvasIntegration(client);\n    this._replay.initializeSampling();\n  }\n\n  /** Setup the integration. */\n   _setup(client) {\n    // Client is not available in constructor, so we need to wait until setupOnce\n    const finalOptions = loadReplayOptionsFromClient(this._initialOptions, client);\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   _maybeLoadFromReplayCanvasIntegration(client) {\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 canvasIntegration = client.getIntegrationByName('ReplayCanvas')\n\n;\n      if (!canvasIntegration) {\n        return;\n      }\n\n      this._replay['_canvas'] = canvasIntegration.getOptions();\n    } catch (e) {\n      // ignore errors here\n    }\n    /* eslint-enable @typescript-eslint/no-non-null-assertion */\n  }\n}Replay.__initStatic();\n\n/** Parse Replay-related options from SDK options */\nfunction loadReplayOptionsFromClient(initialOptions, client) {\n  const opt = client.getOptions() ;\n\n  const finalOptions = {\n    sessionSampleRate: 0,\n    errorSampleRate: 0,\n    ...dropUndefinedKeys(initialOptions),\n  };\n\n  const replaysSessionSampleRate = parseSampleRate(opt.replaysSessionSampleRate);\n  const replaysOnErrorSampleRate = parseSampleRate(opt.replaysOnErrorSampleRate);\n\n  if (replaysSessionSampleRate == null && replaysOnErrorSampleRate == null) {\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 (replaysSessionSampleRate != null) {\n    finalOptions.sessionSampleRate = replaysSessionSampleRate;\n  }\n\n  if (replaysOnErrorSampleRate != null) {\n    finalOptions.errorSampleRate = replaysOnErrorSampleRate;\n  }\n\n  return finalOptions;\n}\n\nfunction _getMergedNetworkHeaders(headers) {\n  return [...DEFAULT_NETWORK_HEADERS, ...headers.map(header => header.toLowerCase())];\n}\n\n/**\n * This is a small utility to get a type-safe instance of the Replay integration.\n */\nfunction getReplay() {\n  const client = getClient();\n  return client && client.getIntegrationByName('Replay');\n}\n\nexport { getReplay, replayIntegration };\n//# sourceMappingURL=index.js.map\n","import{compute as t}from\"compute-scroll-into-view\";const o=t=>!1===t?{block:\"end\",inline:\"nearest\"}:(t=>t===Object(t)&&0!==Object.keys(t).length)(t)?t:{block:\"start\",inline:\"nearest\"};function e(e,r){if(!e.isConnected||!(t=>{let o=t;for(;o&&o.parentNode;){if(o.parentNode===document)return!0;o=o.parentNode instanceof ShadowRoot?o.parentNode.host:o.parentNode}return!1})(e))return;const n=(t=>{const o=window.getComputedStyle(t);return{top:parseFloat(o.scrollMarginTop)||0,right:parseFloat(o.scrollMarginRight)||0,bottom:parseFloat(o.scrollMarginBottom)||0,left:parseFloat(o.scrollMarginLeft)||0}})(e);if((t=>\"object\"==typeof t&&\"function\"==typeof t.behavior)(r))return r.behavior(t(e,r));const l=\"boolean\"==typeof r||null==r?void 0:r.behavior;for(const{el:a,top:i,left:s}of t(e,o(r))){const t=i-n.top+n.bottom,o=s-n.left+n.right;a.scroll({top:t,left:o,behavior:l})}}export{e as default};//# sourceMappingURL=index.js.map\n"],"names":["DEBUG_BUILD","__SENTRY_DEBUG__","cachedImplementations","getNativeImplementation","name","cached","impl","bind","document","createElement","sandbox","hidden","head","appendChild","contentWindow","removeChild","e","warn","clearCachedImplementation","undefined","setTimeout","rest","DEBOUNCE_DURATION","debounceTimerID","lastCapturedEventType","lastCapturedEventTargetId","addClickKeypressInstrumentationHandler","handler","instrumentDOM","triggerDOMHandler","globalDOMEventHandler","makeDOMEventHandler","addEventListener","forEach","target","targetObj","proto","prototype","hasOwnProperty","originalAddEventListener","type","listener","options","handlers","this","__sentry_instrumentation_handlers__","handlerForType","refCount","call","originalRemoveEventListener","Object","keys","length","globalListener","event","getEventTarget","eventType","tagName","isContentEditable","shouldSkipDOMEvent","_sentryId","isSimilarToLastCapturedEvent","global","clearTimeout","lastHref","addHistoryInstrumentationHandler","instrumentHistory","oldOnPopState","onpopstate","historyReplacementFunction","originalHistoryFunction","args","url","from","to","String","handlerData","apply","location","href","_oO","history","SENTRY_XHR_DATA_KEY","addXhrInstrumentationHandler","instrumentXHR","XMLHttpRequest","xhrproto","open","Proxy","originalOpen","xhrOpenThisArg","xhrOpenArgArray","virtualError","Error","startTimestamp","method","toUpperCase","toString","e2","parseUrl","request_headers","match","__sentry_own_request__","onreadystatechangeHandler","xhrInfo","readyState","status_code","status","endTimestamp","xhr","onreadystatechange","originalOnreadystatechange","onreadystatechangeThisArg","onreadystatechangeArgArray","setRequestHeader","originalSetRequestHeader","setRequestHeaderThisArg","setRequestHeaderArgArray","header","value","toLowerCase","send","originalSend","sendThisArg","sendArgArray","sentryXhrData","body","MAX_INT_AS_BYTES","_lcpEntry","_clsEntry","_performanceCursor","_measurements","startTrackingWebVitals","recordClsStandaloneSpans","performance","mark","fidCleanupCallback","metric","entry","entries","timeOrigin","startTime","unit","lcpCleanupCallback","ttfbCleanupCallback","clsCleanupCallback","standaloneClsEntry","pageloadSpanId","standaloneCLsValue","PerformanceObserver","supportedEntryTypes","includes","supportsLayoutShift","sentSpan","_collectClsOnce","clsValue","logger","log","routeName","getScopeData","transactionName","sources","node","attributes","duration","span","transaction","addEvent","end","sendStandaloneClsSpan","cleanupClsHandler","onHidden","client","unsubscribeStartNavigation","on","activeSpan","rootSpan","spanJSON","op","spanContext","spanId","trackClsAsStandaloneSpan","startTrackingLongTasks","parent","parentOp","start_timestamp","parentStartTimestamp","startTrackingLongAnimationFrames","list","getEntries","scripts","initialScript","invoker","invokerType","sourceURL","sourceFunctionName","sourceCharPosition","observe","buffered","startTrackingInteractions","spanOptions","componentName","addPerformanceEntries","performanceEntries","transactionStartTime","slice","Math","max","entryType","_addPerformanceNavigationTiming","requestStartTimestamp","requestStart","responseEndTimestamp","responseEnd","responseStartTimestamp","responseStart","_addRequest","_addNavigationSpans","navEntry","getNavigationEntry","requestTime","measureStartTimestamp","startTimeStamp","measureEndTimestamp","_addMeasureSpans","firstHidden","getVisibilityWatcher","shouldRecord","firstHiddenTime","resourceUrl","initiatorType","parsedUrl","setResourceEntrySizeData","deliveryType","renderBlockingStatus","protocol","split","pop","host","origin","replace","_addResourceSpans","navigator","connection","effectiveType","setAttribute","rtt","deviceMemory","hardwareConcurrency","_trackNavigator","_addTtfbRequestTimeToMeasurements","fidMark","recordClsOnPageloadSpan","cls","measurementName","measurement","getActivationStart","element","id","trim","loadTime","renderTime","size","source","index","_setWebVitalAttributes","eventEnd","_getEndPropertyNameForNavigationTiming","start","key","dataKey","entryVal","LAST_INTERACTIONS","INTERACTIONS_SPAN_MAP","Map","startTrackingINP","inpCallback","find","INP_ENTRY_MAP","interactionId","interactionType","spanToUse","get","description","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","registerInpInteractionListener","_latestRoute","handleEntries","activeRootSpan","has","last","shift","delete","push","set","bindReporter","callback","thresholds","reportAllChanges","prevValue","delta","forceReport","rating","getRating","initMetric","navigationType","prerendering","wasDiscarded","Date","now","floor","random","opts","po","Promise","resolve","then","assign","runOnce","cb","called","whenActivated","FCPThresholds","CLSThresholds","onCLS","onReport","visibilityWatcher","report","disconnect","onFCP","sessionValue","sessionEntries","hadRecentInput","firstSessionEntry","lastSessionEntry","takeRecords","FIDThresholds","onFID","handleEntry","processingStart","interactionCountEstimate","minKnownInteractionId","Infinity","maxKnownInteractionId","updateEstimate","min","initInteractionCountPolyfill","durationThreshold","longestInteractionList","longestInteractionMap","getInteractionCountForNavigation","interactionCount","entryPreProcessingCallbacks","processInteractionEntry","minLongestInteraction","existingInteraction","latency","interaction","sort","a","b","splice","i","whenIdle","rIC","requestIdleCallback","handle","visibilityState","INPThresholds","onINP","PerformanceEventTiming","inp","candidateInteractionIndex","estimateP98LongestInteraction","LCPThresholds","reportedMetricIDs","onLCP","stopListening","once","capture","TTFBThresholds","whenReady","onTTFB","navigationEntry","instrumented","_previousCls","_previousFid","_previousLcp","_previousTtfb","_previousInp","addClsInstrumentationHandler","stopOnCallback","addMetricObserver","instrumentCls","addLcpInstrumentationHandler","instrumentLcp","addFidInstrumentationHandler","instrumentFid","addTtfbInstrumentationHandler","instrumentTtfb","addInpInstrumentationHandler","instrumentInp","addPerformanceInstrumentationHandler","addHandler","triggerHandlers","instrumentPerformanceObserver","getCleanupCallback","data","typeHandlers","error","instrumentFn","previousValue","indexOf","isPerformanceEventTiming","isMeasurementValue","isFinite","startAndEndSpan","parentSpan","startTimeInSeconds","endTime","ctx","parentStartTime","updateStartTime","startStandaloneWebVitalSpan","passedAttributes","release","environment","getOptions","replay","getIntegrationByName","replayId","getReplayId","scope","user","getUser","userDisplay","email","ip_address","profileId","contexts","profile","profile_id","replay_id","userAgent","experimental","standalone","getBrowserPerformanceAPI","msToSec","time","activationStart","checkResponseStart","getEntriesByType","onVisibilityUpdate","timeStamp","removeChangeListeners","removeEventListener","onHiddenOrPageHide","WINDOW","REPLAY_SESSION_KEY","UNABLE_TO_SEND_REPLAY","NETWORK_BODY_MAX_SIZE","CONSOLE_ARG_MAX_SIZE","REPLAY_MAX_EVENT_BUFFER_SIZE","_nullishCoalesce$1","lhs","rhsFn","_optionalChain$5","ops","lastAccessLHS","fn","NodeType$3","isShadowRoot","n","_","Boolean","_2","shadowRoot","isNativeShadowDom","stringifyStylesheet","s","rules","cssRules","cssText","Array","stringifyRule","join","rule","importStringified","isCSSImportRule","styleSheet","statement","JSON","stringify","layerName","supportsText","media","mediaText","escapeImportStatement","isCSSStyleRule","needsSafariColonFix","selectorText","needsAllFix","style","styles","styleDeclaration","attribute","isImportant","getPropertyPriority","getPropertyValue","fixAllCssProperty","NodeType","Mirror","constructor","idNodeMap","nodeMetaMap","WeakMap","getId","_3","getMeta","_4","_5","getNode","getIds","removeNodeFromMap","childNodes","childNode","hasNode","add","meta","oldNode","reset","shouldMaskInput","maskInputOptions","maskInputValue","isMasked","maskInputFn","text","repeat","str","ORIGINAL_ATTRIBUTE_NAME","getInputType","hasAttribute","getInputValue","el","getAttribute","extractFileExtension","path","baseURL","URL","window","err","pathname","_6","cachedImplementations$1","getImplementation$1","setTimeout$2","clearTimeout$2","getIframeContentDocument","iframe","contentDocument","_id","tagNameRegex","RegExp","genId","canvasService","canvasCtx","URL_IN_CSS_REF","URL_PROTOCOL_MATCH","URL_WWW_MATCH","DATA_URI","absoluteToStylesheet","quote1","path1","quote2","path2","path3","filePath","maybeQuote","test","extractOrigin","stack","parts","part","SRCSET_NOT_SPACES","SRCSET_COMMAS_OR_SPACES","cachedDocument","absoluteToDoc","doc","attributeValue","getHref","customHref","startsWith","transformAttribute","maskAttributeFn","pos","collectCharacters","regEx","chars","exec","substring","output","descriptorsStr","inParens","c","charAt","getAbsoluteSrcsetString","ignoreAttribute","_value","distanceToMatch","matchPredicate","limit","distance","nodeType","ELEMENT_NODE","parentNode","createMatchPredicate","className","selector","matches","regex","eIndex","classList","elementClassMatchesRegex","needMaskingText","maskTextClass","maskTextSelector","unmaskTextClass","unmaskTextSelector","maskAllText","parentElement","autocomplete","maskDistance","unmaskDistance","lowerIfExists","maybeAttr","serializeNodeWithId","mirror","blockClass","blockSelector","unblockSelector","skipChild","inlineStylesheet","maskTextFn","slimDOMOptions","dataURLOptions","inlineImages","recordCanvas","onSerialize","onIframeLoad","iframeLoadTimeout","onStylesheetLoad","stylesheetLoadTimeout","keepIframeSrcFn","newlyAddedElement","preserveWhiteSpace","_serializedNode","rootId","docId","getRootId","DOCUMENT_NODE","compatMode","Document","DOCUMENT_TYPE_NODE","DocumentType","publicId","systemId","needBlock","contains","_isBlockedElement","HTMLFormElement","processedTagName","getValidTagName","len","attr","stylesheet","styleSheets","rel","crossorigin","_cssText","sheet","innerText","textContent","checked","forceMask","selected","__context","canvas","getContext","x","width","y","height","getImageData","originalGetImageData","Uint32Array","buffer","some","pixel","is2DCanvasBlank","rr_dataURL","toDataURL","quality","canvasDataURL","blankCanvas","image","imageSrc","currentSrc","priorCrossOrigin","crossOrigin","recordInlineImage","naturalWidth","naturalHeight","drawImage","complete","console","removeAttribute","rr_mediaState","paused","rr_mediaCurrentTime","currentTime","scrollLeft","rr_scrollLeft","scrollTop","rr_scrollTop","getBoundingClientRect","class","rr_width","rr_height","isCustomElement","src","rr_src","customElements","Element","isSVG","ownerSVGElement","isCustom","serializeElementNode","TEXT_NODE","parentTagName","isStyle","isScript","isTextarea","nextSibling","previousSibling","_7","_8","_9","textarea","Text","serializeTextNode","CDATA_SECTION_NODE","CDATA","COMMENT_NODE","Comment","serializeNode","sn","comment","script","headFavicon","headMetaDescKeywords","headMetaSocial","property","headMetaRobots","headMetaHttpEquiv","headMetaAuthorship","headMetaVerification","slimDOMExcluded","serializedNode","recordChild","isShadowHost","headWhitespace","bypassOptions","childN","serializedChildNode","isElement$1","isShadow","iframeEl","win","fired","timer","blankUrl","onceIframeLoaded","iframeDoc","serializedIframeNode","link","styleSheetLoadTimeout","styleSheetLoaded","onceStylesheetLoaded","serializedLinkNode","_optionalChain$4","passive","DEPARTED_MIRROR_ACCESS_WARNING","_mirror","map","throttle$1","func","wait","timeout","previous","leading","remaining","context","getImplementation","clearTimeout$1","trailing","setTimeout$1","hookSetter","d","isRevoked","original","getOwnPropertyDescriptor","defineProperty","patch","replacement","wrapped","defineProperties","__rrweb_original__","enumerable","Reflect","prop","receiver","nowTimestamp","getWindowScroll","left","scrollingElement","pageXOffset","documentElement","top","pageYOffset","_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","getStyle","generateId","getShadowHost","shadowHost","_19","getRootNode","_20","_21","Node","DOCUMENT_FRAGMENT_NODE","inDom","ownerDocument","rootShadowHost","getRootShadowHost","shadowHostInDom","NodeType$1","NodeType$2","EventType","EventType2","IncrementalSource","IncrementalSource2","MouseInteractions","MouseInteractions2","PointerTypes","PointerTypes2","getIFrameContentDocument","_optionalChain$3","isNodeInLinkedList","DoubleLinkedList","tail","position","current","next","addNode","__ln","removeNode","moveKey","parentId","MutationBuffer","frozen","locked","texts","attributeMap","removes","mapRemoves","movedMap","addedSet","Set","movedSet","droppedSet","processMutations","mutations","processMutation","emit","adds","addedIds","addList","getNextId","ns","nextId","pushAdd","currentN","iframeManager","addIframe","stylesheetManager","trackLinkElement","shadowDomManager","addShadowRoot","childSn","attachIframe","canvasManager","addWindow","observeAttachShadow","attachLinkElement","isParentRemoved","isAncestorInSet","candidate","tailNode","_node","unhandledNode","payload","filter","diffAsStr","styleDiff","unchangedAsStr","_unchangedStyles","mutationCb","m","oldValue","attributeName","isInputMasked","item","unattachedDoc","implementation","createHTMLDocument","old","pname","newValue","newPriority","addedNodes","genAdds","removedNodes","nodeId","isSerialized","deepDelete","processedNodeManager","inOtherBuffer","targetId","init","freeze","unfreeze","isFrozen","lock","unlock","addsSet","r","_isParentRemoved","_isAncestorInSet","errorHandler","registerErrorHandler","unregisterErrorHandler","callbackWrapper","_optionalChain$2","mutationBuffers","composedPath","initMutationObserver","rootEl","mutationBuffer","mutationObserverCtor","MutationObserver","__rrMutationObserver","angularZoneSymbol","Zone","__symbol__","observer","onMutation","attributeOldValue","characterData","characterDataOldValue","childList","subtree","initScrollObserver","scrollCb","sampling","evt","defaultView","scrollLeftTop","scroll","INPUT_TAGS","lastInputValueMap","initInputObserver","inputCb","ignoreClass","ignoreSelector","userTriggeredOnInput","eventHandler","userTriggered","isTrusted","isChecked","cbWithDedup","querySelectorAll","v","lastInputValue","eventName","currentWindow","h","propertyDescriptor","HTMLInputElement","hookProperties","HTMLSelectElement","HTMLTextAreaElement","HTMLOptionElement","p","getNestedCSSRulePositions","childRule","hasNestedCSSRule","parentRule","CSSGroupingRule","CSSMediaRule","CSSSupportsRule","CSSConditionRule","unshift","parentStyleSheet","recurse","getIdAndStyleId","styleMirror","styleId","ownerNode","initAdoptedStyleSheetObserver","hostId","patchTarget","ShadowRoot","originalPropertyDescriptor","configurable","sheets","result","_15","_16","adoptStyleSheets","initObservers","o","_hooks","mutationObserver","recordDOM","mousemoveHandler","mousemoveCb","mousemove","threshold","callbackThreshold","mousemoveCallback","timeBaseline","positions","wrappedCb","totalOffset","timeOffset","updatePosition","clientX","clientY","DragEvent","Drag","MouseEvent","MouseMove","TouchMove","initMoveObserver","mouseInteractionHandler","mouseInteractionCb","mouseInteraction","disableMap","currentPointerType","Number","isNaN","endsWith","eventKey","pointerType","thisEventKey","Mouse","Touch","Pen","MouseDown","MouseUp","Click","getHandler","PointerEvent","TouchStart","TouchEnd","initMouseInteractionObserver","scrollHandler","viewportResizeHandler","viewportResizeCb","lastH","lastW","initViewportResizeObserver","inputHandler","mediaInteractionHandler","mediaInteractionCb","volume","muted","playbackRate","initMediaInteractionObserver","styleSheetObserver","adoptedStyleSheetObserver","styleDeclarationObserver","fontObserver","styleSheetRuleCb","CSSStyleSheet","insertRule","thisArg","argumentsList","deleteRule","replaceSync","supportedNestedCSSRuleTypes","canMonkeyPatchNestedCSSRule","unmodifiedFunctions","typeKey","initStyleSheetObserver","styleDeclarationCb","ignoreCSSAttributes","setProperty","CSSStyleDeclaration","priority","_17","removeProperty","remove","initStyleDeclarationObserver","collectFonts","fontCb","fontMap","originalFontFace","FontFace","family","descriptors","fontFace","fontSource","Uint8Array","restoreHandler","fonts","initFontObserver","selectionObserver","param","selectionCb","collapsed","updateSelection","selection","getSelection","isCollapsed","ranges","count","rangeCount","range","getRangeAt","startContainer","startOffset","endContainer","endOffset","initSelectionObserver","customElementObserver","customElementCb","define","initCustomElementObserver","pluginHandlers","plugin","plugins","_22","_23","CrossOriginIframeMirror","generateIdFn","iframeIdToRemoteIdMap","iframeRemoteIdToIdMap","remoteId","idToRemoteMap","remoteToIdMap","idToRemoteIdMap","getIdToRemoteIdMap","remoteIdToIdMap","getRemoteIdToIdMap","getRemoteId","getRemoteIds","ids","_optionalChain$1","IframeManagerNoop","crossOriginIframeMirror","crossOriginIframeRootIdMap","addLoadListener","IframeManager","iframes","crossOriginIframeMap","wrappedEmit","recordCrossOriginIframes","crossOriginIframeStyleMirror","handleMessage","loadListener","isAttachIframe","adoptedStyleSheets","message","crossOriginMessageEvent","transformedEvent","transformCrossOriginEvent","isCheckout","FullSnapshot","replaceIdOnNode","patchRootIdOnNode","timestamp","IncrementalSnapshot","Mutation","Meta","Load","DomContentLoaded","Plugin","Custom","replaceIds","ViewportResize","MediaInteraction","MouseInteraction","Scroll","CanvasMutation","Input","StyleSheetRule","StyleDeclaration","replaceStyleIds","Font","Selection","AdoptedStyleSheet","iframeMirror","obj","isArray","child","ShadowDomManagerNoop","ShadowDomManager","shadowDoms","WeakSet","restoreHandlers","patchAttachShadow","iframeElement","iframeWindow","getIFrameContentWindow","manager","option","resetShadowRoots","CanvasManagerNoop","snapshot","StylesheetManager","trackedLinkElements","adoptedStyleSheetCb","linkEl","trackStylesheetInLinkElement","adoptedStyleSheetData","styleIds","CSSRule","ProcessedNodeManager","nodeMap","active","thisBuffer","buffers","onRequestAnimationFrame","destroy","_takeFullSnapshot","cleanFrame","debug","record","checkoutEveryNms","checkoutEveryNth","maskAllInputs","_maskInputOptions","_slimDOMOptions","maxCanvasSize","packFn","mousemoveWait","recordAfter","getCanvasManager","inEmittingFrame","passEmitsToParent","color","date","month","number","search","tel","week","select","radio","checkbox","lastFullSnapshotEvent","NodeList","DOMTokenList","TypeError","polyfill","incrementalSnapshotCount","eventProcessor","buf","postMessage","exceedCount","exceedTime","takeFullSnapshot","wrappedMutationEmit","wrappedScrollEmit","wrappedCanvasMutationEmit","__RRWEB_EXCLUDE_IFRAME__","getMirror","nodeMirror","getCanvasManagerFn","_getCanvasManager","__RRWEB_EXCLUDE_SHADOW_DOM__","slimDOM","initialOffset","canvasMutationCb","CustomElement","timestampToMs","timestampToS","addBreadcrumbEvent","breadcrumb","category","triggerUserActivity","checkAndHandleExpiredSession","addUpdate","throttledAddEvent","tag","getClosestInteractive","closest","getClickTargetNode","getTargetNode","isEventWithTarget","IncrementalMutationSources","ClickDetector","slowClickConfig","_addBreadcrumbEvent","_lastMutation","_lastScroll","_clicks","_timeout","_threshold","_scrollTimeout","scrollTimeout","_replay","_ignoreSelector","addListeners","cleanupWindowOpen","nowInSeconds","originalWindowOpen","_teardown","removeListeners","_checkClickTimeout","handleClick","SLOW_CLICK_TAGS","ignoreElement","isClickBreadcrumb","newClick","clickBreadcrumb","clickCount","abs","_scheduleCheckClicks","registerMutation","registerScroll","registerClick","_handleMultiClick","_getClicks","_checkClicks","timedOutClicks","mutationAfter","scrollAfter","_generateBreadcrumbs","hadScroll","hadMutation","isSlowClick","timeAfterClickMs","endReason","route","getCurrentRoute","createBreadcrumb","ATTRIBUTES_TO_RECORD","getAttributesToRecord","normalizedKey","getBaseDomBreadcrumb","isElement","ENTRY_TYPES","resource","decodedBodySize","encodedBodySize","responseStatus","transferSize","getAbsoluteTime","statusCode","paint","navigation","domComplete","domContentLoadedEventStart","domContentLoadedEventEnd","domInteractive","loadEventStart","loadEventEnd","redirectCount","webVitalHandler","getter","replayPerformanceEntries","createPerformanceEntry","getLargestContentfulPaint","lastEntry","getWebVital","isLayoutShift","getCumulativeLayoutShift","layoutShifts","nodes","nodeIds","getFirstInputDelay","getInteractionToNextPaint","attributions","CONSOLE_LEVELS","PREFIX","_addBreadcrumb","level","_capture","_trace","_logger","exception","infoTick","setConfig","captureExceptions","traceInternals","info","makeReplayLogger","EventBufferSizeExceededError","super","EventBufferArray","events","_totalSize","hasCheckout","waitForCheckout","hasEvents","eventSize","finish","eventsRet","clear","getEarliestTimestamp","WorkerHandler","worker","_worker","ensureReady","_ensureReadyPromise","reject","success","terminate","arg","_getAndIncrementId","response","EventBufferCompressionWorker","_earliestTimestamp","_sendEventToWorker","_finishRequest","EventBufferProxy","_fallback","_compression","_used","_ensureWorkerIsLoadedPromise","_ensureWorkerIsLoaded","ensureWorkerIsLoaded","_switchToCompressionWorker","addEventPromises","all","hasSessionStorage","sessionStorage","isSampled","sampleRate","makeSession","session","started","lastActivity","segmentId","sampled","previousSessionId","saveSession","setItem","createSession","sessionSampleRate","allowBuffering","stickySession","getSessionSampleType","isExpired","initialTime","expiry","targetTime","isSessionExpired","maxReplayDuration","sessionIdleExpire","shouldRefreshSession","loadOrCreateSession","sessionOptions","existingSession","sessionStringFromStorage","getItem","sessionObj","parse","fetchSession","addEventSync","shouldAddEvent","_addEvent","async","eventBuffer","isBufferMode","recordingMode","eventAfterPossibleCallback","isCustomEvent","maybeApplyCallback","beforeAddRecordingEvent","isExceeded","reason","handleException","stop","recordDroppedEvent","isPaused","isEnabled","timestampInMs","timeouts","sessionIdlePause","initialTimestamp","isErrorEvent","isTransactionEvent","isFeedbackEvent","isBreadcrumbWithCategory","resetReplayIdOnDynamicSamplingContext","dsc","getPropagationContext","createPerformanceSpans","addNetworkBreadcrumb","_experiments","shouldFilterRequest","getBodySize","textEncoder","TextEncoder","encode","URLSearchParams","FormData","formDataStr","_serializeFormData","Blob","ArrayBuffer","byteLength","parseContentLengthHeader","parseInt","getBodyString","mergeWarning","warning","headers","_meta","warnings","newMeta","existingWarnings","makeNetworkReplayBreadcrumb","request","buildSkippedNetworkRequestOrResponse","bodySize","buildNetworkRequestOrResponse","normalizedBody","exceedsSizeLimit","isProbablyJson","first","_strIsProbablyJson","truncatedBody","normalizeNetworkBody","getAllowedHeaders","allowedHeaders","reduce","filteredHeaders","formData","urlMatches","urls","fullUrl","baseURI","fixedUrl","getFullUrl","_getFetchRequestArgBody","fetchArgs","getAllHeaders","allHeaders","getHeadersFromOptions","Headers","handleNetworkBreadcrumbs","networkDetailAllowUrls","networkDetailDenyUrls","networkCaptureBodies","networkRequestHeaders","networkResponseHeaders","hint","_isXhrBreadcrumb","_isXhrHint","reqSize","resSize","getResponseHeader","responseType","_getBodySize","request_body_size","response_body_size","enrichXhrBreadcrumb","requestBodySize","responseBodySize","getAllResponseHeaders","acc","line","getResponseHeaders","requestBody","requestWarning","responseBody","responseWarning","errors","responseText","outerHTML","_parseXhrResponse","_getXhrResponseBody","_prepareXhrData","captureXhrBreadcrumbToReplay","_isFetchBreadcrumb","_isFetchHint","enrichFetchBreadcrumb","captureDetails","bodyStr","_getRequestInfo","bodyText","res","clone","_tryCloneResponse","_getResponseText","txt","finally","_tryGetResponseText","_parseFetchResponseBody","getResponseData","_getResponseInfo","_prepareFetchData","captureFetchBreadcrumbToReplay","beforeAddNetworkBreadcrumb","createMemoryEntry","memoryEntry","jsHeapSizeLimit","totalJSHeapSize","usedJSHeapSize","memory","NAVIGATOR","getHandleRecordingEmit","hadFirstEvent","_isCheckout","clickDetector","isIncrementalEvent","isIncrementalMouseInteraction","HTMLElement","updateClickDetectorForRecordingEvent","setInitialState","shouldRecordCanvas","isRecordingCanvas","errorSampleRate","useCompressionOption","useCompression","blockAllMedia","networkDetailHasUrls","networkRequestHasHeaders","networkResponseHasHeaders","createOptionsEvent","addSettingsEvent","earliestEvent","flush","TransportStatusCodeError","RateLimitError","rateLimits","sendReplay","replayData","retryConfig","interval","recordingData","onError","segment_id","eventContext","preparedRecordingData","payloadWithSequence","replayHeaders","sequence","prepareRecordingData","errorIds","traceIds","transport","getTransport","dsn","getDsn","baseEvent","replay_start_timestamp","error_ids","trace_ids","replay_type","replayEvent","event_id","eventHint","integrations","_integrations","preparedEvent","platform","metadata","getSdkMetadata","version","sdk","prepareReplayEvent","sdkProcessingMetadata","envelope","tunnel","createReplayEnvelope","cause","sendReplayRequest","_retryCount","THROTTLED","ReplayContainer","recordingOptions","__init","__init2","__init3","__init4","__init5","__init6","_lastActivity","_isEnabled","_isPaused","_requiresManualStart","_hasInitializedCoreListeners","_context","initialUrl","_recordingOptions","_options","_debouncedFlush","callbackReturnValue","timerId","maxTimerId","maxWait","invokeFunc","cancelTimers","debounced","cancel","debounce","_flush","flushMinDelay","flushMaxDelay","_throttledAddEvent","maxCount","durationSeconds","counter","isThrottled","_cleanup","values","wasThrottled","throttle","slowClickTimeout","slowClickIgnoreSelectors","experiments","_canvas","initializeSampling","requiresManualStart","_initializeSessionForSampling","_initializeRecording","_updateUserActivity","startBuffering","startRecording","canvasOptions","_stopRecording","continuousCheckout","maxTouchPoints","_onMutationHandler","stopRecording","forceFlush","_removeListeners","force","removeItem","deleteSession","pause","resume","_checkSession","sendBufferedReplayOrFlush","continueRecording","flushImmediate","activityTime","hasStoppedRecording","_updateSessionActivity","_maybeSaveSession","cbResult","updateUserActivity","conditionalFlush","cancelFlush","getSessionId","urlPath","hash","_clearContext","lastActiveSpan","lastRootSpan","workerUrl","customWorkerUrl","Worker","__SENTRY_EXCLUDE_REPLAY_WORKER__","createObjectURL","_loadWorker","createEventBuffer","_addListeners","currentSession","_refreshSession","_handleVisibilityChange","_handleWindowBlur","_handleWindowFocus","_handleKeyboardEvent","isClick","maxStringLength","getDomTarget","handleDom","altKey","metaKey","ctrlKey","shiftKey","handleDomListener","handleHistory","handleHistorySpanListener","arguments","isTruncated","normalizedArgs","normalizedArg","normalizeConsoleBreadcrumb","normalizeBreadcrumb","beforeAddBreadcrumb","handleBreadcrumbs","isReplayEvent","breadcrumbs","feedback","feedbackId","addFeedbackBreadcrumb","originalException","__rrweb__","isRrwebError","isErrorEventSampled","shouldSampleForBufferEvent","tags","handleGlobalEventListener","exceptionValue","handleHydrationError","handleBeforeSendEvent","sendResponse","replayContext","trace","trace_id","handleTransactionEvent","beforeErrorSampling","handleErrorEvent","handleAfterSendEvent","feedbackEvent","includeReplay","addGlobalListeners","_performanceCleanupCallback","addPerformanceEntry","onEntries","clearCallbacks","clearCallback","setupPerformanceObserver","_doChangeToForegroundTasks","_doChangeToBackgroundTasks","isInputElement","hasModifierKey","isCharacterKey","getKeyboardBreadcrumb","handleKeyboardEvent","_createCustomBreadcrumb","_addPerformanceEntries","concat","initialTimestampInSeconds","_updateInitialTimestampFromEventBuffer","_popEventContext","_runFlush","addMemoryEntry","dropReason","tooShort","minReplayDuration","tooLong","_flushInProgress","_flushLock","mutationLimit","overMutationLimit","mutationBreadcrumbLimit","getOption","selectors","defaultSelectors","MEDIA_SELECTORS","DEFAULT_NETWORK_HEADERS","_initialized","replayIntegration","Replay","__initStatic","MAX_REPLAY_DURATION","mask","maskAttributes","unmask","block","unblock","ignore","maskFn","privacyOptions","getPrivacyOptions","password","maskAttribute","_initialOptions","_getMergedNetworkHeaders","_isInitialized","afterAllSetup","_setup","_initialize","getRecordingMode","_maybeLoadFromReplayCanvasIntegration","finalOptions","initialOptions","opt","replaysSessionSampleRate","replaysOnErrorSampleRate","loadReplayOptionsFromClient","canvasIntegration","t","inline","isConnected","getComputedStyle","parseFloat","scrollMarginTop","right","scrollMarginRight","bottom","scrollMarginBottom","scrollMarginLeft","behavior","l"],"sourceRoot":""}