{"version":3,"file":"d904c7bf-d9a7ae465fcf083b28e1.js","mappings":"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","sources":["webpack://sarp-prioritization-tool/./node_modules/@sentry-internal/replay/build/npm/esm/index.js"],"sourcesContent":["import { GLOBAL_OBJ, normalize, fill, htmlTreeAsString, browserPerformanceTimeOrigin, logger as logger$1, severityLevelFromString, captureException, addBreadcrumb, uuid4, getClient, getLocationHref, getCurrentScope, getActiveSpan, getDynamicSamplingContextFromSpan, isSentryRequestUrl, 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, serializeFormData, getFetchRequestArgBody, getBodyString, 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\nvar __defProp$1 = Object.defineProperty;\nvar __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== \"symbol\" ? key + \"\" : key, value);\nvar NodeType$2 = /* @__PURE__ */ ((NodeType2) => {\n  NodeType2[NodeType2[\"Document\"] = 0] = \"Document\";\n  NodeType2[NodeType2[\"DocumentType\"] = 1] = \"DocumentType\";\n  NodeType2[NodeType2[\"Element\"] = 2] = \"Element\";\n  NodeType2[NodeType2[\"Text\"] = 3] = \"Text\";\n  NodeType2[NodeType2[\"CDATA\"] = 4] = \"CDATA\";\n  NodeType2[NodeType2[\"Comment\"] = 5] = \"Comment\";\n  return NodeType2;\n})(NodeType$2 || {});\nfunction isElement$1(n2) {\n  return n2.nodeType === n2.ELEMENT_NODE;\n}\nfunction isShadowRoot(n2) {\n  const host = n2?.host;\n  return Boolean(host?.shadowRoot === n2);\n}\nfunction isNativeShadowDom(shadowRoot) {\n  return Object.prototype.toString.call(shadowRoot) === \"[object ShadowRoot]\";\n}\nfunction fixBrowserCompatibilityIssuesInCSS(cssText) {\n  if (cssText.includes(\" background-clip: text;\") && !cssText.includes(\" -webkit-background-clip: text;\")) {\n    cssText = cssText.replace(\n      /\\sbackground-clip:\\s*text;/g,\n      \" -webkit-background-clip: text; background-clip: text;\"\n    );\n  }\n  return cssText;\n}\nfunction escapeImportStatement(rule) {\n  const { cssText } = rule;\n  if (cssText.split('\"').length < 3) return cssText;\n  const statement = [\"@import\", `url(${JSON.stringify(rule.href)})`];\n  if (rule.layerName === \"\") {\n    statement.push(`layer`);\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(s2) {\n  try {\n    const rules2 = s2.rules || s2.cssRules;\n    return rules2 ? fixBrowserCompatibilityIssuesInCSS(\n      Array.from(rules2, stringifyRule).join(\"\")\n    ) : null;\n  } catch (error) {\n    return null;\n  }\n}\nfunction fixAllCssProperty(rule) {\n  let styles = \"\";\n  for (let i2 = 0; i2 < rule.style.length; i2++) {\n    const styleDeclaration = rule.style;\n    const attribute = styleDeclaration[i2];\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 = // for same-origin stylesheets,\n      // we can access the imported stylesheet rules directly\n      stringifyStylesheet(rule.styleSheet) || // work around browser issues with the raw string `@import url(...)` statement\n      escapeImportStatement(rule);\n    } catch (error) {\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    __publicField$1(this, \"idNodeMap\", /* @__PURE__ */ new Map());\n    __publicField$1(this, \"nodeMetaMap\", /* @__PURE__ */ new WeakMap());\n  }\n  getId(n2) {\n    if (!n2) return -1;\n    const id = this.getMeta(n2)?.id;\n    return 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(n2) {\n    return this.nodeMetaMap.get(n2) || null;\n  }\n  // removes the node from idNodeMap\n  // doesn't remove the node from nodeMetaMap\n  removeNodeFromMap(n2) {\n    const id = this.getId(n2);\n    this.idNodeMap.delete(id);\n    if (n2.childNodes) {\n      n2.childNodes.forEach(\n        (childNode) => this.removeNodeFromMap(childNode)\n      );\n    }\n  }\n  has(id) {\n    return this.idNodeMap.has(id);\n  }\n  hasNode(node) {\n    return this.nodeMetaMap.has(node);\n  }\n  add(n2, meta) {\n    const id = meta.id;\n    this.idNodeMap.set(id, n2);\n    this.nodeMetaMap.set(n2, meta);\n  }\n  replace(id, n2) {\n    const oldNode = this.getNode(id);\n    if (oldNode) {\n      const meta = this.nodeMetaMap.get(oldNode);\n      if (meta) this.nodeMetaMap.set(n2, meta);\n    }\n    this.idNodeMap.set(id, n2);\n  }\n  reset() {\n    this.idNodeMap = /* @__PURE__ */ new Map();\n    this.nodeMetaMap = /* @__PURE__ */ new WeakMap();\n  }\n}\nfunction createMirror$2() {\n  return new Mirror();\n}\nfunction shouldMaskInput({\n  maskInputOptions,\n  tagName,\n  type\n}) {\n  if (tagName === \"OPTION\") {\n    tagName = \"SELECT\";\n  }\n  return Boolean(\n    maskInputOptions[tagName.toLowerCase()] || type && maskInputOptions[type] || type === \"password\" || // Default to \"text\" option for inputs without a \"type\" attribute defined\n    tagName === \"INPUT\" && !type && maskInputOptions[\"text\"]\n  );\n}\nfunction maskInputValue({\n  isMasked,\n  element,\n  value,\n  maskInputFn\n}) {\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) 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 ? getImageData[ORIGINAL_ATTRIBUTE_NAME] : getImageData;\n      const pixelBuffer = new Uint32Array(\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access\n        originalGetImageData.call(\n          ctx,\n          x,\n          y,\n          Math.min(chunkSize, canvas.width - x),\n          Math.min(chunkSize, canvas.height - y)\n        ).data.buffer\n      );\n      if (pixelBuffer.some((pixel) => pixel !== 0)) return false;\n    }\n  }\n  return true;\n}\nfunction getInputType(element) {\n  const type = element.type;\n  return element.hasAttribute(\"data-rr-is-password\") ? \"password\" : type ? (\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\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, baseURL ?? window.location.href);\n  } catch (err) {\n    return null;\n  }\n  const regex = /\\.([0-9a-z]+)(?:$)/i;\n  const match = url.pathname.match(regex);\n  return match?.[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 document2 = window.document;\n  let impl = window[name];\n  if (document2 && typeof document2.createElement === \"function\") {\n    try {\n      const sandbox = document2.createElement(\"iframe\");\n      sandbox.hidden = true;\n      document2.head.appendChild(sandbox);\n      const contentWindow = sandbox.contentWindow;\n      if (contentWindow && contentWindow[name]) {\n        impl = // eslint-disable-next-line @typescript-eslint/unbound-method\n        contentWindow[name];\n      }\n      document2.head.removeChild(sandbox);\n    } catch (e2) {\n    }\n  }\n  return cachedImplementations$1[name] = impl.bind(\n    window\n  );\n}\nfunction setTimeout$2(...rest) {\n  return getImplementation$1(\"setTimeout\")(...rest);\n}\nfunction clearTimeout$1(...rest) {\n  return getImplementation$1(\"clearTimeout\")(...rest);\n}\nfunction getIframeContentDocument(iframe) {\n  try {\n    return iframe.contentDocument;\n  } catch (e2) {\n  }\n}\nlet _id = 1;\nconst tagNameRegex = new RegExp(\"[^a-z0-9-_:]\");\nconst IGNORED_NODE = -2;\nfunction genId() {\n  return _id++;\n}\nfunction getValidTagName$1(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  } 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(\n    URL_IN_CSS_REF,\n    (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        } else if (part === \"..\") {\n          stack.pop();\n        } else {\n          stack.push(part);\n        }\n      }\n      return `url(${maybeQuote}${stack.join(\"/\")}${maybeQuote})`;\n    }\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 chars2;\n    const match = regEx.exec(attributeValue.substring(pos));\n    if (match) {\n      chars2 = match[0];\n      pos += chars2.length;\n      return chars2;\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    } else {\n      let descriptorsStr = \"\";\n      url = absoluteToDoc(doc, url);\n      let inParens = false;\n      while (true) {\n        const c2 = attributeValue.charAt(pos);\n        if (c2 === \"\") {\n          output.push((url + descriptorsStr).trim());\n          break;\n        } else if (!inParens) {\n          if (c2 === \",\") {\n            pos += 1;\n            output.push((url + descriptorsStr).trim());\n            break;\n          } else if (c2 === \"(\") {\n            inParens = true;\n          }\n        } else {\n          if (c2 === \")\") {\n            inParens = false;\n          }\n        }\n        descriptorsStr += c2;\n        pos += 1;\n      }\n    }\n  }\n  return output.join(\", \");\n}\nconst cachedDocument = /* @__PURE__ */ 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 a2 = cachedDocument.get(doc);\n  if (!a2) {\n    a2 = doc.createElement(\"a\");\n    cachedDocument.set(doc, a2);\n  }\n  if (!customHref) {\n    customHref = \"\";\n  } else if (customHref.startsWith(\"blob:\") || customHref.startsWith(\"data:\")) {\n    return customHref;\n  }\n  a2.setAttribute(\"href\", customHref);\n  return a2.href;\n}\nfunction transformAttribute(doc, tagName, name, value, element, maskAttributeFn) {\n  if (!value) {\n    return value;\n  }\n  if (name === \"src\" || name === \"href\" && !(tagName === \"use\" && value[0] === \"#\")) {\n    return absoluteToDoc(doc, value);\n  } else if (name === \"xlink:href\" && value[0] !== \"#\") {\n    return absoluteToDoc(doc, value);\n  } else if (name === \"background\" && (tagName === \"table\" || tagName === \"td\" || tagName === \"th\")) {\n    return absoluteToDoc(doc, value);\n  } else if (name === \"srcset\") {\n    return getAbsoluteSrcsetString(doc, value);\n  } else if (name === \"style\") {\n    return absoluteToStylesheet(value, getHref(doc));\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    } 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  } catch (e2) {\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) return -1;\n  if (node.nodeType !== node.ELEMENT_NODE) return -1;\n  if (distance > limit) return -1;\n  if (matchPredicate(node)) 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) return false;\n    try {\n      if (className) {\n        if (typeof className === \"string\") {\n          if (el.matches(`.${className}`)) return true;\n        } else if (elementClassMatchesRegex(el, className)) {\n          return true;\n        }\n      }\n      if (selector && el.matches(selector)) return true;\n      return false;\n    } catch {\n      return false;\n    }\n  };\n}\nfunction needMaskingText(node, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, maskAllText) {\n  try {\n    const el = node.nodeType === node.ELEMENT_NODE ? node : node.parentElement;\n    if (el === null) 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(\n        el,\n        createMatchPredicate(unmaskTextClass, unmaskTextSelector)\n      );\n      if (unmaskDistance < 0) {\n        return true;\n      }\n      maskDistance = distanceToMatch(\n        el,\n        createMatchPredicate(maskTextClass, maskTextSelector),\n        unmaskDistance >= 0 ? unmaskDistance : Infinity\n      );\n    } else {\n      maskDistance = distanceToMatch(\n        el,\n        createMatchPredicate(maskTextClass, maskTextSelector)\n      );\n      if (maskDistance < 0) {\n        return false;\n      }\n      unmaskDistance = distanceToMatch(\n        el,\n        createMatchPredicate(unmaskTextClass, unmaskTextSelector),\n        maskDistance >= 0 ? maskDistance : Infinity\n      );\n    }\n    return maskDistance >= 0 ? unmaskDistance >= 0 ? maskDistance <= unmaskDistance : true : unmaskDistance >= 0 ? false : !!maskAllText;\n  } catch (e2) {\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  } 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$1(timer);\n      fired = true;\n      listener();\n    });\n    return;\n  }\n  const blankUrl = \"about:blank\";\n  if (win.location.href !== blankUrl || iframeEl.src === blankUrl || 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  } catch (error) {\n    return;\n  }\n  if (styleSheetLoaded) return;\n  const timer = setTimeout$2(() => {\n    if (!fired) {\n      listener();\n      fired = true;\n    }\n  }, styleSheetLoadTimeout);\n  link.addEventListener(\"load\", () => {\n    clearTimeout$1(timer);\n    fired = true;\n    listener();\n  });\n}\nfunction serializeNode(n2, options) {\n  const {\n    doc,\n    mirror: mirror2,\n    blockClass,\n    blockSelector,\n    unblockSelector,\n    maskAllText,\n    maskAttributeFn,\n    maskTextClass,\n    unmaskTextClass,\n    maskTextSelector,\n    unmaskTextSelector,\n    inlineStylesheet,\n    maskInputOptions = {},\n    maskTextFn,\n    maskInputFn,\n    dataURLOptions = {},\n    inlineImages,\n    recordCanvas,\n    keepIframeSrcFn,\n    newlyAddedElement = false\n  } = options;\n  const rootId = getRootId(doc, mirror2);\n  switch (n2.nodeType) {\n    case n2.DOCUMENT_NODE:\n      if (n2.compatMode !== \"CSS1Compat\") {\n        return {\n          type: NodeType$2.Document,\n          childNodes: [],\n          compatMode: n2.compatMode\n          // probably \"BackCompat\"\n        };\n      } else {\n        return {\n          type: NodeType$2.Document,\n          childNodes: []\n        };\n      }\n    case n2.DOCUMENT_TYPE_NODE:\n      return {\n        type: NodeType$2.DocumentType,\n        name: n2.name,\n        publicId: n2.publicId,\n        systemId: n2.systemId,\n        rootId\n      };\n    case n2.ELEMENT_NODE:\n      return serializeElementNode(n2, {\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        maskTextClass,\n        unmaskTextClass,\n        maskTextSelector,\n        unmaskTextSelector\n      });\n    case n2.TEXT_NODE:\n      return serializeTextNode(n2, {\n        doc,\n        maskAllText,\n        maskTextClass,\n        unmaskTextClass,\n        maskTextSelector,\n        unmaskTextSelector,\n        maskTextFn,\n        maskInputOptions,\n        maskInputFn,\n        rootId\n      });\n    case n2.CDATA_SECTION_NODE:\n      return {\n        type: NodeType$2.CDATA,\n        textContent: \"\",\n        rootId\n      };\n    case n2.COMMENT_NODE:\n      return {\n        type: NodeType$2.Comment,\n        textContent: n2.textContent || \"\",\n        rootId\n      };\n    default:\n      return false;\n  }\n}\nfunction getRootId(doc, mirror2) {\n  if (!mirror2.hasNode(doc)) return void 0;\n  const docId = mirror2.getId(doc);\n  return docId === 1 ? void 0 : docId;\n}\nfunction serializeTextNode(n2, options) {\n  const {\n    maskAllText,\n    maskTextClass,\n    unmaskTextClass,\n    maskTextSelector,\n    unmaskTextSelector,\n    maskTextFn,\n    maskInputOptions,\n    maskInputFn,\n    rootId\n  } = options;\n  const parentTagName = n2.parentNode && n2.parentNode.tagName;\n  let textContent = n2.textContent;\n  const isStyle = parentTagName === \"STYLE\" ? true : void 0;\n  const isScript = parentTagName === \"SCRIPT\" ? true : void 0;\n  const isTextarea = parentTagName === \"TEXTAREA\" ? true : void 0;\n  if (isStyle && textContent) {\n    try {\n      if (n2.nextSibling || n2.previousSibling) {\n      } else if (n2.parentNode.sheet?.cssRules) {\n        textContent = stringifyStylesheet(\n          n2.parentNode.sheet\n        );\n      }\n    } catch (err) {\n      console.warn(\n        `Cannot get CSS styles from text's parentNode. Error: ${err}`,\n        n2\n      );\n    }\n    textContent = absoluteToStylesheet(textContent, getHref(options.doc));\n  }\n  if (isScript) {\n    textContent = \"SCRIPT_PLACEHOLDER\";\n  }\n  const forceMask = needMaskingText(\n    n2,\n    maskTextClass,\n    maskTextSelector,\n    unmaskTextClass,\n    unmaskTextSelector,\n    maskAllText\n  );\n  if (!isStyle && !isScript && !isTextarea && textContent && forceMask) {\n    textContent = maskTextFn ? maskTextFn(textContent, n2.parentElement) : textContent.replace(/[\\S]/g, \"*\");\n  }\n  if (isTextarea && textContent && (maskInputOptions.textarea || forceMask)) {\n    textContent = maskInputFn ? maskInputFn(textContent, n2.parentNode) : 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        n2,\n        maskTextClass,\n        maskTextSelector,\n        unmaskTextClass,\n        unmaskTextSelector,\n        isInputMasked\n      ),\n      element: n2,\n      value: textContent,\n      maskInputFn\n    });\n  }\n  return {\n    type: NodeType$2.Text,\n    textContent: textContent || \"\",\n    isStyle,\n    rootId\n  };\n}\nfunction serializeElementNode(n2, options) {\n  const {\n    doc,\n    blockClass,\n    blockSelector,\n    unblockSelector,\n    inlineStylesheet,\n    maskInputOptions = {},\n    maskAttributeFn,\n    maskInputFn,\n    dataURLOptions = {},\n    inlineImages,\n    recordCanvas,\n    keepIframeSrcFn,\n    newlyAddedElement = false,\n    rootId,\n    maskTextClass,\n    unmaskTextClass,\n    maskTextSelector,\n    unmaskTextSelector\n  } = options;\n  const needBlock = _isBlockedElement(\n    n2,\n    blockClass,\n    blockSelector,\n    unblockSelector\n  );\n  const tagName = getValidTagName$1(n2);\n  let attributes2 = {};\n  const len = n2.attributes.length;\n  for (let i2 = 0; i2 < len; i2++) {\n    const attr = n2.attributes[i2];\n    if (attr.name && !ignoreAttribute(tagName, attr.name, attr.value)) {\n      attributes2[attr.name] = transformAttribute(\n        doc,\n        tagName,\n        toLowerCase(attr.name),\n        attr.value,\n        n2,\n        maskAttributeFn\n      );\n    }\n  }\n  if (tagName === \"link\" && inlineStylesheet) {\n    const stylesheet = Array.from(doc.styleSheets).find((s2) => {\n      return s2.href === n2.href;\n    });\n    let cssText = null;\n    if (stylesheet) {\n      cssText = stringifyStylesheet(stylesheet);\n    }\n    if (cssText) {\n      attributes2.rel = null;\n      attributes2.href = null;\n      attributes2.crossorigin = null;\n      attributes2._cssText = absoluteToStylesheet(cssText, stylesheet.href);\n    }\n  }\n  if (tagName === \"style\" && n2.sheet && // TODO: Currently we only try to get dynamic stylesheet when it is an empty style element\n  !(n2.innerText || n2.textContent || \"\").trim().length) {\n    const cssText = stringifyStylesheet(\n      n2.sheet\n    );\n    if (cssText) {\n      attributes2._cssText = absoluteToStylesheet(cssText, getHref(doc));\n    }\n  }\n  if (tagName === \"input\" || tagName === \"textarea\" || tagName === \"select\" || tagName === \"option\") {\n    const el = n2;\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(\n        el,\n        maskTextClass,\n        maskTextSelector,\n        unmaskTextClass,\n        unmaskTextSelector,\n        shouldMaskInput({\n          type,\n          tagName: toUpperCase(tagName),\n          maskInputOptions\n        })\n      );\n      attributes2.value = maskInputValue({\n        isMasked: forceMask,\n        element: el,\n        value,\n        maskInputFn\n      });\n    }\n    if (checked) {\n      attributes2.checked = checked;\n    }\n  }\n  if (tagName === \"option\") {\n    if (n2.selected && !maskInputOptions[\"select\"]) {\n      attributes2.selected = true;\n    } else {\n      delete attributes2.selected;\n    }\n  }\n  if (tagName === \"canvas\" && recordCanvas) {\n    if (n2.__context === \"2d\") {\n      if (!is2DCanvasBlank(n2)) {\n        attributes2.rr_dataURL = n2.toDataURL(\n          dataURLOptions.type,\n          dataURLOptions.quality\n        );\n      }\n    } else if (!(\"__context\" in n2)) {\n      const canvasDataURL = n2.toDataURL(\n        dataURLOptions.type,\n        dataURLOptions.quality\n      );\n      const blankCanvas = doc.createElement(\"canvas\");\n      blankCanvas.width = n2.width;\n      blankCanvas.height = n2.height;\n      const blankCanvasDataURL = blankCanvas.toDataURL(\n        dataURLOptions.type,\n        dataURLOptions.quality\n      );\n      if (canvasDataURL !== blankCanvasDataURL) {\n        attributes2.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 = n2;\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        attributes2.rr_dataURL = canvasService.toDataURL(\n          dataURLOptions.type,\n          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 image.addEventListener(\"load\", recordInlineImage);\n          return;\n        } else {\n          console.warn(\n            `Cannot inline img src=${imageSrc}! Error: ${err}`\n          );\n        }\n      }\n      if (image.crossOrigin === \"anonymous\") {\n        priorCrossOrigin ? attributes2.crossOrigin = priorCrossOrigin : image.removeAttribute(\"crossorigin\");\n      }\n    };\n    if (image.complete && image.naturalWidth !== 0) recordInlineImage();\n    else image.addEventListener(\"load\", recordInlineImage);\n  }\n  if (tagName === \"audio\" || tagName === \"video\") {\n    attributes2.rr_mediaState = n2.paused ? \"paused\" : \"played\";\n    attributes2.rr_mediaCurrentTime = n2.currentTime;\n  }\n  if (!newlyAddedElement) {\n    if (n2.scrollLeft) {\n      attributes2.rr_scrollLeft = n2.scrollLeft;\n    }\n    if (n2.scrollTop) {\n      attributes2.rr_scrollTop = n2.scrollTop;\n    }\n  }\n  if (needBlock) {\n    const { width, height } = n2.getBoundingClientRect();\n    attributes2 = {\n      class: attributes2.class,\n      rr_width: `${width}px`,\n      rr_height: `${height}px`\n    };\n  }\n  if (tagName === \"iframe\" && !keepIframeSrcFn(attributes2.src)) {\n    if (!needBlock && !getIframeContentDocument(n2)) {\n      attributes2.rr_src = attributes2.src;\n    }\n    delete attributes2.src;\n  }\n  let isCustomElement;\n  try {\n    if (customElements.get(tagName)) isCustomElement = true;\n  } catch (e2) {\n  }\n  return {\n    type: NodeType$2.Element,\n    tagName,\n    attributes: attributes2,\n    childNodes: [],\n    isSVG: isSVGElement(n2) || void 0,\n    needBlock,\n    rootId,\n    isCustom: isCustomElement\n  };\n}\nfunction lowerIfExists(maybeAttr) {\n  if (maybeAttr === void 0 || maybeAttr === null) {\n    return \"\";\n  } else {\n    return maybeAttr.toLowerCase();\n  }\n}\nfunction slimDOMExcluded(sn, slimDOMOptions) {\n  if (slimDOMOptions.comment && sn.type === NodeType$2.Comment) {\n    return true;\n  } else if (sn.type === NodeType$2.Element) {\n    if (slimDOMOptions.script && // script tag\n    (sn.tagName === \"script\" || // (module)preload link\n    sn.tagName === \"link\" && (sn.attributes.rel === \"preload\" || sn.attributes.rel === \"modulepreload\") || // prefetch link\n    sn.tagName === \"link\" && sn.attributes.rel === \"prefetch\" && typeof sn.attributes.href === \"string\" && extractFileExtension(sn.attributes.href) === \"js\")) {\n      return true;\n    } else if (slimDOMOptions.headFavicon && (sn.tagName === \"link\" && sn.attributes.rel === \"shortcut icon\" || sn.tagName === \"meta\" && (lowerIfExists(sn.attributes.name).match(\n      /^msapplication-tile(image|color)$/\n    ) || lowerIfExists(sn.attributes.name) === \"application-name\" || lowerIfExists(sn.attributes.rel) === \"icon\" || lowerIfExists(sn.attributes.rel) === \"apple-touch-icon\" || lowerIfExists(sn.attributes.rel) === \"shortcut icon\"))) {\n      return true;\n    } else if (sn.tagName === \"meta\") {\n      if (slimDOMOptions.headMetaDescKeywords && lowerIfExists(sn.attributes.name).match(/^description|keywords$/)) {\n        return true;\n      } else if (slimDOMOptions.headMetaSocial && (lowerIfExists(sn.attributes.property).match(/^(og|twitter|fb):/) || // og = opengraph (facebook)\n      lowerIfExists(sn.attributes.name).match(/^(og|twitter):/) || lowerIfExists(sn.attributes.name) === \"pinterest\")) {\n        return true;\n      } else if (slimDOMOptions.headMetaRobots && (lowerIfExists(sn.attributes.name) === \"robots\" || lowerIfExists(sn.attributes.name) === \"googlebot\" || lowerIfExists(sn.attributes.name) === \"bingbot\")) {\n        return true;\n      } else if (slimDOMOptions.headMetaHttpEquiv && sn.attributes[\"http-equiv\"] !== void 0) {\n        return true;\n      } else if (slimDOMOptions.headMetaAuthorship && (lowerIfExists(sn.attributes.name) === \"author\" || lowerIfExists(sn.attributes.name) === \"generator\" || lowerIfExists(sn.attributes.name) === \"framework\" || lowerIfExists(sn.attributes.name) === \"publisher\" || lowerIfExists(sn.attributes.name) === \"progid\" || lowerIfExists(sn.attributes.property).match(/^article:/) || lowerIfExists(sn.attributes.property).match(/^product:/))) {\n        return true;\n      } else if (slimDOMOptions.headMetaVerification && (lowerIfExists(sn.attributes.name) === \"google-site-verification\" || lowerIfExists(sn.attributes.name) === \"yandex-verification\" || lowerIfExists(sn.attributes.name) === \"csrf-token\" || lowerIfExists(sn.attributes.name) === \"p:domain_verify\" || lowerIfExists(sn.attributes.name) === \"verify-v1\" || lowerIfExists(sn.attributes.name) === \"verification\" || lowerIfExists(sn.attributes.name) === \"shopify-checkout-api-token\")) {\n        return true;\n      }\n    }\n  }\n  return false;\n}\nfunction serializeNodeWithId(n2, options) {\n  const {\n    doc,\n    mirror: mirror2,\n    blockClass,\n    blockSelector,\n    unblockSelector,\n    maskAllText,\n    maskTextClass,\n    unmaskTextClass,\n    maskTextSelector,\n    unmaskTextSelector,\n    skipChild = false,\n    inlineStylesheet = true,\n    maskInputOptions = {},\n    maskAttributeFn,\n    maskTextFn,\n    maskInputFn,\n    slimDOMOptions,\n    dataURLOptions = {},\n    inlineImages = false,\n    recordCanvas = false,\n    onSerialize,\n    onIframeLoad,\n    iframeLoadTimeout = 5e3,\n    onStylesheetLoad,\n    stylesheetLoadTimeout = 5e3,\n    keepIframeSrcFn = () => false,\n    newlyAddedElement = false\n  } = options;\n  let { preserveWhiteSpace = true } = options;\n  const _serializedNode = serializeNode(n2, {\n    doc,\n    mirror: mirror2,\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(n2, \"not serialized\");\n    return null;\n  }\n  let id;\n  if (mirror2.hasNode(n2)) {\n    id = mirror2.getId(n2);\n  } else if (slimDOMExcluded(_serializedNode, slimDOMOptions) || !preserveWhiteSpace && _serializedNode.type === NodeType$2.Text && !_serializedNode.isStyle && !_serializedNode.textContent.replace(/^\\s+|\\s+$/gm, \"\").length) {\n    id = IGNORED_NODE;\n  } else {\n    id = genId();\n  }\n  const serializedNode2 = Object.assign(_serializedNode, { id });\n  mirror2.add(n2, serializedNode2);\n  if (id === IGNORED_NODE) {\n    return null;\n  }\n  if (onSerialize) {\n    onSerialize(n2);\n  }\n  let recordChild = !skipChild;\n  if (serializedNode2.type === NodeType$2.Element) {\n    recordChild = recordChild && !serializedNode2.needBlock;\n    delete serializedNode2.needBlock;\n    const shadowRoot = n2.shadowRoot;\n    if (shadowRoot && isNativeShadowDom(shadowRoot))\n      serializedNode2.isShadowHost = true;\n  }\n  if ((serializedNode2.type === NodeType$2.Document || serializedNode2.type === NodeType$2.Element) && recordChild) {\n    if (slimDOMOptions.headWhitespace && serializedNode2.type === NodeType$2.Element && serializedNode2.tagName === \"head\") {\n      preserveWhiteSpace = false;\n    }\n    const bypassOptions = {\n      doc,\n      mirror: mirror2,\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(n2.childNodes)) {\n      const serializedChildNode = serializeNodeWithId(childN, bypassOptions);\n      if (serializedChildNode) {\n        serializedNode2.childNodes.push(serializedChildNode);\n      }\n    }\n    if (isElement$1(n2) && n2.shadowRoot) {\n      for (const childN of Array.from(n2.shadowRoot.childNodes)) {\n        const serializedChildNode = serializeNodeWithId(childN, bypassOptions);\n        if (serializedChildNode) {\n          isNativeShadowDom(n2.shadowRoot) && (serializedChildNode.isShadow = true);\n          serializedNode2.childNodes.push(serializedChildNode);\n        }\n      }\n    }\n  }\n  if (n2.parentNode && isShadowRoot(n2.parentNode) && isNativeShadowDom(n2.parentNode)) {\n    serializedNode2.isShadow = true;\n  }\n  if (serializedNode2.type === NodeType$2.Element && serializedNode2.tagName === \"iframe\" && !_isBlockedElement(\n    n2,\n    blockClass,\n    blockSelector,\n    unblockSelector\n  )) {\n    onceIframeLoaded(\n      n2,\n      () => {\n        const iframeDoc = getIframeContentDocument(n2);\n        if (iframeDoc && onIframeLoad) {\n          const serializedIframeNode = serializeNodeWithId(iframeDoc, {\n            doc: iframeDoc,\n            mirror: mirror2,\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              n2,\n              serializedIframeNode\n            );\n          }\n        }\n      },\n      iframeLoadTimeout\n    );\n  }\n  if (serializedNode2.type === NodeType$2.Element && serializedNode2.tagName === \"link\" && typeof serializedNode2.attributes.rel === \"string\" && (serializedNode2.attributes.rel === \"stylesheet\" || serializedNode2.attributes.rel === \"preload\" && typeof serializedNode2.attributes.href === \"string\" && extractFileExtension(serializedNode2.attributes.href) === \"css\")) {\n    onceStylesheetLoaded(\n      n2,\n      () => {\n        if (onStylesheetLoad) {\n          const serializedLinkNode = serializeNodeWithId(n2, {\n            doc,\n            mirror: mirror2,\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              n2,\n              serializedLinkNode\n            );\n          }\n        }\n      },\n      stylesheetLoadTimeout\n    );\n  }\n  return serializedNode2;\n}\nfunction snapshot(n2, options) {\n  const {\n    mirror: mirror2 = new Mirror(),\n    blockClass = \"rr-block\",\n    blockSelector = null,\n    unblockSelector = null,\n    maskAllText = false,\n    maskTextClass = \"rr-mask\",\n    unmaskTextClass = null,\n    maskTextSelector = null,\n    unmaskTextSelector = null,\n    inlineStylesheet = true,\n    inlineImages = false,\n    recordCanvas = false,\n    maskAllInputs = false,\n    maskAttributeFn,\n    maskTextFn,\n    maskInputFn,\n    slimDOM = false,\n    dataURLOptions,\n    preserveWhiteSpace,\n    onSerialize,\n    onIframeLoad,\n    iframeLoadTimeout,\n    onStylesheetLoad,\n    stylesheetLoadTimeout,\n    keepIframeSrcFn = () => false\n  } = options || {};\n  const maskInputOptions = maskAllInputs === true ? {\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  } : maskAllInputs === false ? {} : maskAllInputs;\n  const slimDOMOptions = slimDOM === true || slimDOM === \"all\" ? (\n    // if true: set of sensible options that should not throw away any information\n    {\n      script: true,\n      comment: true,\n      headFavicon: true,\n      headWhitespace: true,\n      headMetaDescKeywords: slimDOM === \"all\",\n      // destructive\n      headMetaSocial: true,\n      headMetaRobots: true,\n      headMetaHttpEquiv: true,\n      headMetaAuthorship: true,\n      headMetaVerification: true\n    }\n  ) : slimDOM === false ? {} : slimDOM;\n  return serializeNodeWithId(n2, {\n    doc: n2,\n    mirror: mirror2,\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}\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,\\r\\nnow you can use replayer.getMirror() to access the mirror instance of a replayer,\\r\\nor 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$2(timeout);\n        timeout = null;\n      }\n      previous = now;\n      func.apply(context, args);\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(\n    target,\n    key,\n    isRevoked ? d : {\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  );\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  } catch {\n    return () => {\n    };\n  }\n}\nlet nowTimestamp = Date.now;\nif (!/* @__PURE__ */ /[1-9][0-9]{12}/.test(Date.now().toString())) {\n  nowTimestamp = () => (/* @__PURE__ */ new Date()).getTime();\n}\nfunction getWindowScroll(win) {\n  const doc = win.document;\n  return {\n    left: doc.scrollingElement ? doc.scrollingElement.scrollLeft : win.pageXOffset !== void 0 ? win.pageXOffset : doc?.documentElement.scrollLeft || doc?.body?.parentElement?.scrollLeft || doc?.body?.scrollLeft || 0,\n    top: doc.scrollingElement ? doc.scrollingElement.scrollTop : win.pageYOffset !== void 0 ? win.pageYOffset : doc?.documentElement.scrollTop || doc?.body?.parentElement?.scrollTop || doc?.body?.scrollTop || 0\n  };\n}\nfunction getWindowHeight() {\n  return window.innerHeight || document.documentElement && document.documentElement.clientHeight || document.body && document.body.clientHeight;\n}\nfunction getWindowWidth() {\n  return window.innerWidth || document.documentElement && document.documentElement.clientWidth || document.body && document.body.clientWidth;\n}\nfunction closestElementOfNode(node) {\n  if (!node) {\n    return null;\n  }\n  try {\n    const el = node.nodeType === node.ELEMENT_NODE ? node : node.parentElement;\n    return el;\n  } catch (error) {\n    return null;\n  }\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(\n      el,\n      createMatchPredicate(null, unblockSelector)\n    );\n  }\n  if (blockDistance > -1 && unblockDistance < 0) {\n    return true;\n  }\n  return blockDistance < unblockDistance;\n}\nfunction isSerialized(n2, mirror2) {\n  return mirror2.getId(n2) !== -1;\n}\nfunction isIgnored(n2, mirror2) {\n  return mirror2.getId(n2) === IGNORED_NODE;\n}\nfunction isAncestorRemoved(target, mirror2) {\n  if (isShadowRoot(target)) {\n    return false;\n  }\n  const id = mirror2.getId(target);\n  if (!mirror2.has(id)) {\n    return true;\n  }\n  if (target.parentNode && target.parentNode.nodeType === target.DOCUMENT_NODE) {\n    return false;\n  }\n  if (!target.parentNode) {\n    return true;\n  }\n  return isAncestorRemoved(target.parentNode, mirror2);\n}\nfunction legacy_isTouchEvent(event) {\n  return Boolean(event.changedTouches);\n}\nfunction polyfill$1(win = window) {\n  if (\"NodeList\" in win && !win.NodeList.prototype.forEach) {\n    win.NodeList.prototype.forEach = Array.prototype.forEach;\n  }\n  if (\"DOMTokenList\" in win && !win.DOMTokenList.prototype.forEach) {\n    win.DOMTokenList.prototype.forEach = Array.prototype.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(n2, mirror2) {\n  return Boolean(n2.nodeName === \"IFRAME\" && mirror2.getMeta(n2));\n}\nfunction isSerializedStylesheet(n2, mirror2) {\n  return Boolean(\n    n2.nodeName === \"LINK\" && n2.nodeType === n2.ELEMENT_NODE && n2.getAttribute && n2.getAttribute(\"rel\") === \"stylesheet\" && mirror2.getMeta(n2)\n  );\n}\nfunction hasShadowRoot(n2) {\n  return Boolean(n2?.shadowRoot);\n}\nclass StyleSheetMirror {\n  constructor() {\n    this.id = 1;\n    this.styleIDMap = /* @__PURE__ */ new WeakMap();\n    this.idStyleMap = /* @__PURE__ */ new Map();\n  }\n  getId(stylesheet) {\n    return this.styleIDMap.get(stylesheet) ?? -1;\n  }\n  has(stylesheet) {\n    return this.styleIDMap.has(stylesheet);\n  }\n  /**\n   * @returns If the stylesheet is in the mirror, returns the id of the stylesheet. If not, return the new assigned id.\n   */\n  add(stylesheet, id) {\n    if (this.has(stylesheet)) return this.getId(stylesheet);\n    let newId;\n    if (id === void 0) {\n      newId = this.id++;\n    } else 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 = /* @__PURE__ */ new WeakMap();\n    this.idStyleMap = /* @__PURE__ */ new Map();\n    this.id = 1;\n  }\n  generateId() {\n    return this.id++;\n  }\n}\nfunction getShadowHost(n2) {\n  let shadowHost = null;\n  if (n2.getRootNode?.()?.nodeType === Node.DOCUMENT_FRAGMENT_NODE && n2.getRootNode().host)\n    shadowHost = n2.getRootNode().host;\n  return shadowHost;\n}\nfunction getRootShadowHost(n2) {\n  let rootShadowHost = n2;\n  let shadowHost;\n  while (shadowHost = getShadowHost(rootShadowHost))\n    rootShadowHost = shadowHost;\n  return rootShadowHost;\n}\nfunction shadowHostInDom(n2) {\n  const doc = n2.ownerDocument;\n  if (!doc) return false;\n  const shadowHost = getRootShadowHost(n2);\n  return doc.contains(shadowHost);\n}\nfunction inDom(n2) {\n  const doc = n2.ownerDocument;\n  if (!doc) return false;\n  return doc.contains(n2) || shadowHostInDom(n2);\n}\nconst cachedImplementations = {};\nfunction getImplementation(name) {\n  const cached = cachedImplementations[name];\n  if (cached) {\n    return cached;\n  }\n  const document2 = window.document;\n  let impl = window[name];\n  if (document2 && typeof document2.createElement === \"function\") {\n    try {\n      const sandbox = document2.createElement(\"iframe\");\n      sandbox.hidden = true;\n      document2.head.appendChild(sandbox);\n      const contentWindow = sandbox.contentWindow;\n      if (contentWindow && contentWindow[name]) {\n        impl = // eslint-disable-next-line @typescript-eslint/unbound-method\n        contentWindow[name];\n      }\n      document2.head.removeChild(sandbox);\n    } catch (e2) {\n    }\n  }\n  return cachedImplementations[name] = impl.bind(\n    window\n  );\n}\nfunction onRequestAnimationFrame(...rest) {\n  return getImplementation(\"requestAnimationFrame\")(...rest);\n}\nfunction setTimeout$1(...rest) {\n  return getImplementation(\"setTimeout\")(...rest);\n}\nfunction clearTimeout$2(...rest) {\n  return getImplementation(\"clearTimeout\")(...rest);\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 || {});\nvar MediaInteractions = /* @__PURE__ */ ((MediaInteractions2) => {\n  MediaInteractions2[MediaInteractions2[\"Play\"] = 0] = \"Play\";\n  MediaInteractions2[MediaInteractions2[\"Pause\"] = 1] = \"Pause\";\n  MediaInteractions2[MediaInteractions2[\"Seeked\"] = 2] = \"Seeked\";\n  MediaInteractions2[MediaInteractions2[\"VolumeChange\"] = 3] = \"VolumeChange\";\n  MediaInteractions2[MediaInteractions2[\"RateChange\"] = 4] = \"RateChange\";\n  return MediaInteractions2;\n})(MediaInteractions || {});\nfunction getIFrameContentDocument(iframe) {\n  try {\n    return iframe.contentDocument;\n  } catch (e2) {\n  }\n}\nfunction getIFrameContentWindow(iframe) {\n  try {\n    return iframe.contentWindow;\n  } catch (e2) {\n  }\n}\nfunction isNodeInLinkedList(n2) {\n  return \"__ln\" in n2;\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 = current?.next || null;\n    }\n    return current;\n  }\n  addNode(n2) {\n    const node = {\n      value: n2,\n      previous: null,\n      next: null\n    };\n    n2.__ln = node;\n    if (n2.previousSibling && isNodeInLinkedList(n2.previousSibling)) {\n      const current = n2.previousSibling.__ln.next;\n      node.next = current;\n      node.previous = n2.previousSibling.__ln;\n      n2.previousSibling.__ln.next = node;\n      if (current) {\n        current.previous = node;\n      }\n    } else if (n2.nextSibling && isNodeInLinkedList(n2.nextSibling) && n2.nextSibling.__ln.previous) {\n      const current = n2.nextSibling.__ln.previous;\n      node.previous = current;\n      node.next = n2.nextSibling.__ln;\n      n2.nextSibling.__ln.previous = node;\n      if (current) {\n        current.next = node;\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(n2) {\n    const current = n2.__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      } else {\n        this.tail = null;\n      }\n    } else {\n      current.previous.next = current.next;\n      if (current.next) {\n        current.next.previous = current.previous;\n      } else {\n        this.tail = current.previous;\n      }\n    }\n    if (n2.__ln) {\n      delete n2.__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 = /* @__PURE__ */ new WeakMap();\n    this.removes = [];\n    this.mapRemoves = [];\n    this.movedMap = {};\n    this.addedSet = /* @__PURE__ */ new Set();\n    this.movedSet = /* @__PURE__ */ new Set();\n    this.droppedSet = /* @__PURE__ */ 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 = /* @__PURE__ */ new Set();\n      const addList = new DoubleLinkedList();\n      const getNextId = (n2) => {\n        let ns = n2;\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 = (n2) => {\n        if (!n2.parentNode || !inDom(n2)) {\n          return;\n        }\n        const parentId = isShadowRoot(n2.parentNode) ? this.mirror.getId(getShadowHost(n2)) : this.mirror.getId(n2.parentNode);\n        const nextId = getNextId(n2);\n        if (parentId === -1 || nextId === -1) {\n          return addList.addNode(n2);\n        }\n        const sn = serializeNodeWithId(n2, {\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) && !isBlocked(\n              currentN,\n              this.blockClass,\n              this.blockSelector,\n              this.unblockSelector,\n              false\n            )) {\n              this.iframeManager.addIframe(currentN);\n            }\n            if (isSerializedStylesheet(currentN, this.mirror)) {\n              this.stylesheetManager.trackLinkElement(\n                currentN\n              );\n            }\n            if (hasShadowRoot(n2)) {\n              this.shadowDomManager.addShadowRoot(n2.shadowRoot, this.doc);\n            }\n          },\n          onIframeLoad: (iframe, childSn) => {\n            if (isBlocked(\n              iframe,\n              this.blockClass,\n              this.blockSelector,\n              this.unblockSelector,\n              false\n            )) {\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 n2 of this.movedSet) {\n        if (isParentRemoved(this.removes, n2, this.mirror) && !this.movedSet.has(n2.parentNode)) {\n          continue;\n        }\n        pushAdd(n2);\n      }\n      for (const n2 of this.addedSet) {\n        if (!isAncestorInSet(this.droppedSet, n2) && !isParentRemoved(this.removes, n2, this.mirror)) {\n          pushAdd(n2);\n        } else if (isAncestorInSet(this.movedSet, n2)) {\n          pushAdd(n2);\n        } else {\n          this.droppedSet.add(n2);\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) continue;\n              else if (parentId !== -1) {\n                node = _node;\n                break;\n              } else {\n                const unhandledNode = _node.value;\n                if (unhandledNode.parentNode && unhandledNode.parentNode.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n                  const shadowHost = unhandledNode.parentNode.host;\n                  const parentId2 = this.mirror.getId(shadowHost);\n                  if (parentId2 !== -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.map((text) => ({\n          id: this.mirror.getId(text.node),\n          value: text.value\n        })).filter((text) => !addedIds.has(text.id)).filter((text) => this.mirror.has(text.id)),\n        attributes: this.attributes.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 === attributes.style.split(\"var(\").length) {\n                attributes.style = attribute.styleDiff;\n              }\n            }\n          }\n          return {\n            id: this.mirror.getId(attribute.node),\n            attributes\n          };\n        }).filter((attribute) => !addedIds.has(attribute.id)).filter((attribute) => this.mirror.has(attribute.id)),\n        removes: this.removes,\n        adds\n      };\n      if (!payload.texts.length && !payload.attributes.length && !payload.removes.length && !payload.adds.length) {\n        return;\n      }\n      this.texts = [];\n      this.attributes = [];\n      this.attributeMap = /* @__PURE__ */ new WeakMap();\n      this.removes = [];\n      this.addedSet = /* @__PURE__ */ new Set();\n      this.movedSet = /* @__PURE__ */ new Set();\n      this.droppedSet = /* @__PURE__ */ 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(\n            m.target,\n            this.blockClass,\n            this.blockSelector,\n            this.unblockSelector,\n            false\n          ) && value !== m.oldValue) {\n            this.texts.push({\n              value: needMaskingText(\n                m.target,\n                this.maskTextClass,\n                this.maskTextSelector,\n                this.unmaskTextClass,\n                this.unmaskTextSelector,\n                this.maskAllText\n              ) && value ? this.maskTextFn ? this.maskTextFn(value, closestElementOfNode(m.target)) : value.replace(/[\\S]/g, \"*\") : 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(\n              m.target,\n              this.maskTextClass,\n              this.maskTextSelector,\n              this.unmaskTextClass,\n              this.unmaskTextSelector,\n              isInputMasked\n            );\n            value = maskInputValue({\n              isMasked: forceMask,\n              element: target,\n              value,\n              maskInputFn: this.maskInputFn\n            });\n          }\n          if (isBlocked(\n            m.target,\n            this.blockClass,\n            this.blockSelector,\n            this.unblockSelector,\n            false\n          ) || value === m.oldValue) {\n            return;\n          }\n          let item = this.attributeMap.get(m.target);\n          if (target.tagName === \"IFRAME\" && attributeName === \"src\" && !this.keepIframeSrcFn(value)) {\n            const iframeDoc = getIFrameContentDocument(\n              target\n            );\n            if (!iframeDoc) {\n              attributeName = \"rr_src\";\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\" && target.tagName === \"INPUT\" && (m.oldValue || \"\").toLowerCase() === \"password\") {\n            target.setAttribute(\"data-rr-is-password\", \"true\");\n          }\n          if (!ignoreAttribute(target.tagName, attributeName)) {\n            item.attributes[attributeName] = transformAttribute(\n              this.doc,\n              toLowerCase(target.tagName),\n              toLowerCase(attributeName),\n              value,\n              target,\n              this.maskAttributeFn\n            );\n            if (attributeName === \"style\") {\n              if (!this.unattachedDoc) {\n                try {\n                  this.unattachedDoc = document.implementation.createHTMLDocument();\n                } catch (e2) {\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) || newPriority !== old.style.getPropertyPriority(pname)) {\n                  if (newPriority === \"\") {\n                    item.styleDiff[pname] = newValue;\n                  } else {\n                    item.styleDiff[pname] = [newValue, newPriority];\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(\n            m.target,\n            this.blockClass,\n            this.blockSelector,\n            this.unblockSelector,\n            true\n          )) {\n            return;\n          }\n          m.addedNodes.forEach((n2) => this.genAdds(n2, m.target));\n          m.removedNodes.forEach((n2) => {\n            const nodeId = this.mirror.getId(n2);\n            const parentId = isShadowRoot(m.target) ? this.mirror.getId(m.target.host) : this.mirror.getId(m.target);\n            if (isBlocked(\n              m.target,\n              this.blockClass,\n              this.blockSelector,\n              this.unblockSelector,\n              false\n            ) || isIgnored(n2, this.mirror) || !isSerialized(n2, this.mirror)) {\n              return;\n            }\n            if (this.addedSet.has(n2)) {\n              deepDelete(this.addedSet, n2);\n              this.droppedSet.add(n2);\n            } else if (this.addedSet.has(m.target) && nodeId === -1) ;\n            else if (isAncestorRemoved(m.target, this.mirror)) ;\n            else if (this.movedSet.has(n2) && this.movedMap[moveKey(nodeId, parentId)]) {\n              deepDelete(this.movedSet, n2);\n            } else {\n              this.removes.push({\n                parentId,\n                id: nodeId,\n                isShadow: isShadowRoot(m.target) && isNativeShadowDom(m.target) ? true : void 0\n              });\n            }\n            this.mapRemoves.push(n2);\n          });\n          break;\n        }\n      }\n    };\n    this.genAdds = (n2, target) => {\n      if (this.processedNodeManager.inOtherBuffer(n2, this)) return;\n      if (this.addedSet.has(n2) || this.movedSet.has(n2)) return;\n      if (this.mirror.hasNode(n2)) {\n        if (isIgnored(n2, this.mirror)) {\n          return;\n        }\n        this.movedSet.add(n2);\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(n2), targetId)] = true;\n        }\n      } else {\n        this.addedSet.add(n2);\n        this.droppedSet.delete(n2);\n      }\n      if (!isBlocked(\n        n2,\n        this.blockClass,\n        this.blockSelector,\n        this.unblockSelector,\n        false\n      )) {\n        n2.childNodes.forEach((childN) => this.genAdds(childN));\n        if (hasShadowRoot(n2)) {\n          n2.shadowRoot.childNodes.forEach((childN) => {\n            this.processedNodeManager.add(childN, this);\n            this.genAdds(childN, n2);\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, n2) {\n  addsSet.delete(n2);\n  n2.childNodes.forEach((childN) => deepDelete(addsSet, childN));\n}\nfunction isParentRemoved(removes, n2, mirror2) {\n  if (removes.length === 0) return false;\n  return _isParentRemoved(removes, n2, mirror2);\n}\nfunction _isParentRemoved(removes, n2, mirror2) {\n  let node = n2.parentNode;\n  while (node) {\n    const parentId = mirror2.getId(node);\n    if (removes.some((r2) => r2.id === parentId)) {\n      return true;\n    }\n    node = node.parentNode;\n  }\n  return false;\n}\nfunction isAncestorInSet(set, n2) {\n  if (set.size === 0) return false;\n  return _isAncestorInSet(set, n2);\n}\nfunction _isAncestorInSet(set, n2) {\n  const { parentNode } = n2;\n  if (!parentNode) {\n    return false;\n  }\n  if (set.has(parentNode)) {\n    return true;\n  }\n  return _isAncestorInSet(set, parentNode);\n}\nlet errorHandler;\nfunction registerErrorHandler(handler) {\n  errorHandler = handler;\n}\nfunction unregisterErrorHandler() {\n  errorHandler = void 0;\n}\nconst callbackWrapper = (cb) => {\n  if (!errorHandler) {\n    return cb;\n  }\n  const rrwebWrapped = (...rest) => {\n    try {\n      return cb(...rest);\n    } catch (error) {\n      if (errorHandler && errorHandler(error) === true) {\n        return () => {\n        };\n      }\n      throw error;\n    }\n  };\n  return rrwebWrapped;\n};\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    } else if (\"path\" in event && event.path.length) {\n      return event.path[0];\n    }\n  } catch {\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  * Some websites may disable MutationObserver by removing it from the window object.\n  * If someone is using rrweb to build a browser extention or things like it, they\n  * could not change the website's code but can have an opportunity to inject some\n  * code before the website executing its JS logic.\n  * Then they can do this to store the native MutationObserver:\n  * window.__rrMutationObserver = MutationObserver\n  */\n  window.__rrMutationObserver;\n  const angularZoneSymbol = window?.Zone?.__symbol__?.(\"MutationObserver\");\n  if (angularZoneSymbol && window[angularZoneSymbol]) {\n    mutationObserverCtor = window[angularZoneSymbol];\n  }\n  const observer = new mutationObserverCtor(\n    callbackWrapper((mutations) => {\n      if (options.onMutation && options.onMutation(mutations) === false) {\n        return;\n      }\n      mutationBuffer.processMutations.bind(mutationBuffer)(mutations);\n    })\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({\n  mousemoveCb,\n  sampling,\n  doc,\n  mirror: mirror2\n}) {\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\" ? sampling.mousemoveCallback : 500;\n  let positions = [];\n  let timeBaseline;\n  const wrappedCb = throttle$1(\n    callbackWrapper(\n      (source) => {\n        const totalOffset = Date.now() - timeBaseline;\n        mousemoveCb(\n          positions.map((p) => {\n            p.timeOffset -= totalOffset;\n            return p;\n          }),\n          source\n        );\n        positions = [];\n        timeBaseline = null;\n      }\n    ),\n    callbackThreshold\n  );\n  const updatePosition = callbackWrapper(\n    throttle$1(\n      callbackWrapper((evt) => {\n        const target = getEventTarget(evt);\n        const { clientX, clientY } = legacy_isTouchEvent(evt) ? evt.changedTouches[0] : evt;\n        if (!timeBaseline) {\n          timeBaseline = nowTimestamp();\n        }\n        positions.push({\n          x: clientX,\n          y: clientY,\n          id: mirror2.getId(target),\n          timeOffset: nowTimestamp() - timeBaseline\n        });\n        wrappedCb(\n          typeof DragEvent !== \"undefined\" && evt instanceof DragEvent ? IncrementalSource.Drag : evt instanceof MouseEvent ? IncrementalSource.MouseMove : IncrementalSource.TouchMove\n        );\n      }),\n      threshold,\n      {\n        trailing: false\n      }\n    )\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({\n  mouseInteractionCb,\n  doc,\n  mirror: mirror2,\n  blockClass,\n  blockSelector,\n  unblockSelector,\n  sampling\n}) {\n  if (sampling.mouseInteraction === false) {\n    return () => {\n    };\n  }\n  const disableMap = sampling.mouseInteraction === true || sampling.mouseInteraction === void 0 ? {} : 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          } else if (MouseInteractions[eventKey] === MouseInteractions.MouseUp) {\n            thisEventKey = \"TouchEnd\";\n          }\n        } else if (pointerType === PointerTypes.Pen) ;\n      } else if (legacy_isTouchEvent(event)) {\n        pointerType = PointerTypes.Touch;\n      }\n      if (pointerType !== null) {\n        currentPointerType = pointerType;\n        if (thisEventKey.startsWith(\"Touch\") && pointerType === PointerTypes.Touch || thisEventKey.startsWith(\"Mouse\") && pointerType === PointerTypes.Mouse) {\n          pointerType = null;\n        }\n      } else if (MouseInteractions[eventKey] === MouseInteractions.Click) {\n        pointerType = currentPointerType;\n        currentPointerType = null;\n      }\n      const e2 = legacy_isTouchEvent(event) ? event.changedTouches[0] : event;\n      if (!e2) {\n        return;\n      }\n      const id = mirror2.getId(target);\n      const { clientX, clientY } = e2;\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).filter(\n    (key) => Number.isNaN(Number(key)) && !key.endsWith(\"_Departed\") && 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(\n            \"mouse\",\n            \"pointer\"\n          );\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({\n  scrollCb,\n  doc,\n  mirror: mirror2,\n  blockClass,\n  blockSelector,\n  unblockSelector,\n  sampling\n}) {\n  const updatePosition = callbackWrapper(\n    throttle$1(\n      callbackWrapper((evt) => {\n        const target = getEventTarget(evt);\n        if (!target || isBlocked(\n          target,\n          blockClass,\n          blockSelector,\n          unblockSelector,\n          true\n        )) {\n          return;\n        }\n        const id = mirror2.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        } else {\n          scrollCb({\n            id,\n            x: target.scrollLeft,\n            y: target.scrollTop\n          });\n        }\n      }),\n      sampling.scroll || 100\n    )\n  );\n  return on(\"scroll\", updatePosition, doc);\n}\nfunction initViewportResizeObserver({ viewportResizeCb }, { win }) {\n  let lastH = -1;\n  let lastW = -1;\n  const updateDimension = callbackWrapper(\n    throttle$1(\n      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      }),\n      200\n    )\n  );\n  return on(\"resize\", updateDimension, win);\n}\nconst INPUT_TAGS = [\"INPUT\", \"TEXTAREA\", \"SELECT\"];\nconst lastInputValueMap = /* @__PURE__ */ new WeakMap();\nfunction initInputObserver({\n  inputCb,\n  doc,\n  mirror: mirror2,\n  blockClass,\n  blockSelector,\n  unblockSelector,\n  ignoreClass,\n  ignoreSelector,\n  maskInputOptions,\n  maskInputFn,\n  sampling,\n  userTriggeredOnInput,\n  maskTextClass,\n  unmaskTextClass,\n  maskTextSelector,\n  unmaskTextSelector\n}) {\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\") target = target.parentElement;\n    if (!target || !tagName || INPUT_TAGS.indexOf(tagName) < 0 || isBlocked(\n      target,\n      blockClass,\n      blockSelector,\n      unblockSelector,\n      true\n    )) {\n      return;\n    }\n    const el = target;\n    if (el.classList.contains(ignoreClass) || 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(\n      target,\n      maskTextClass,\n      maskTextSelector,\n      unmaskTextClass,\n      unmaskTextSelector,\n      isInputMasked\n    );\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(\n      target,\n      userTriggeredOnInput ? { text, isChecked, userTriggered } : { text, isChecked }\n    );\n    const name = target.name;\n    if (type === \"radio\" && name && isChecked) {\n      doc.querySelectorAll(`input[type=\"radio\"][name=\"${name}\"]`).forEach((el2) => {\n        if (el2 !== target) {\n          const text2 = maskInputValue({\n            // share mask behavior of `target`\n            isMasked: forceMask,\n            element: el2,\n            value: getInputValue(el2, tagName, type),\n            maskInputFn\n          });\n          cbWithDedup(\n            el2,\n            userTriggeredOnInput ? { text: text2, isChecked: !isChecked, userTriggered: false } : { text: text2, isChecked: !isChecked }\n          );\n        }\n      });\n    }\n  }\n  function cbWithDedup(target, v2) {\n    const lastInputValue = lastInputValueMap.get(target);\n    if (!lastInputValue || lastInputValue.text !== v2.text || lastInputValue.isChecked !== v2.isChecked) {\n      lastInputValueMap.set(target, v2);\n      const id = mirror2.getId(target);\n      callbackWrapper(inputCb)({\n        ...v2,\n        id\n      });\n    }\n  }\n  const events = sampling.input === \"last\" ? [\"change\"] : [\"input\", \"change\"];\n  const handlers = events.map(\n    (eventName) => on(eventName, callbackWrapper(eventHandler), doc)\n  );\n  const currentWindow = doc.defaultView;\n  if (!currentWindow) {\n    return () => {\n      handlers.forEach((h) => h());\n    };\n  }\n  const propertyDescriptor = currentWindow.Object.getOwnPropertyDescriptor(\n    currentWindow.HTMLInputElement.prototype,\n    \"value\"\n  );\n  const hookProperties = [\n    [currentWindow.HTMLInputElement.prototype, \"value\"],\n    [currentWindow.HTMLInputElement.prototype, \"checked\"],\n    [currentWindow.HTMLSelectElement.prototype, \"value\"],\n    [currentWindow.HTMLTextAreaElement.prototype, \"value\"],\n    // Some UI library use selectedIndex to set select value\n    [currentWindow.HTMLSelectElement.prototype, \"selectedIndex\"],\n    [currentWindow.HTMLOptionElement.prototype, \"selected\"]\n  ];\n  if (propertyDescriptor && propertyDescriptor.set) {\n    handlers.push(\n      ...hookProperties.map(\n        (p) => hookSetter(\n          p[0],\n          p[1],\n          {\n            set() {\n              callbackWrapper(eventHandler)({\n                target: this,\n                isTrusted: false\n                // userTriggered to false as this could well be programmatic\n              });\n            }\n          },\n          false,\n          currentWindow\n        )\n      )\n    );\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\") && childRule.parentRule instanceof CSSGroupingRule || hasNestedCSSRule(\"CSSMediaRule\") && childRule.parentRule instanceof CSSMediaRule || hasNestedCSSRule(\"CSSSupportsRule\") && childRule.parentRule instanceof CSSSupportsRule || hasNestedCSSRule(\"CSSConditionRule\") && childRule.parentRule instanceof CSSConditionRule) {\n      const rules2 = Array.from(\n        childRule.parentRule.cssRules\n      );\n      const index = rules2.indexOf(childRule);\n      pos.unshift(index);\n    } else if (childRule.parentStyleSheet) {\n      const rules2 = Array.from(childRule.parentStyleSheet.cssRules);\n      const index = rules2.indexOf(childRule);\n      pos.unshift(index);\n    }\n    return pos;\n  }\n  return recurse(rule, positions);\n}\nfunction getIdAndStyleId(sheet, mirror2, styleMirror) {\n  let id, styleId;\n  if (!sheet) return {};\n  if (sheet.ownerNode) id = mirror2.getId(sheet.ownerNode);\n  else styleId = styleMirror.getId(sheet);\n  return {\n    styleId,\n    id\n  };\n}\nfunction initStyleSheetObserver({ styleSheetRuleCb, mirror: mirror2, 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(\n      (target, thisArg, argumentsList) => {\n        const [rule, index] = argumentsList;\n        const { id, styleId } = getIdAndStyleId(\n          thisArg,\n          mirror2,\n          stylesheetManager.styleMirror\n        );\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  });\n  const deleteRule = win.CSSStyleSheet.prototype.deleteRule;\n  win.CSSStyleSheet.prototype.deleteRule = new Proxy(deleteRule, {\n    apply: callbackWrapper(\n      (target, thisArg, argumentsList) => {\n        const [index] = argumentsList;\n        const { id, styleId } = getIdAndStyleId(\n          thisArg,\n          mirror2,\n          stylesheetManager.styleMirror\n        );\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  });\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(\n        (target, thisArg, argumentsList) => {\n          const [text] = argumentsList;\n          const { id, styleId } = getIdAndStyleId(\n            thisArg,\n            mirror2,\n            stylesheetManager.styleMirror\n          );\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  }\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(\n        (target, thisArg, argumentsList) => {\n          const [text] = argumentsList;\n          const { id, styleId } = getIdAndStyleId(\n            thisArg,\n            mirror2,\n            stylesheetManager.styleMirror\n          );\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  }\n  const supportedNestedCSSRuleTypes = {};\n  if (canMonkeyPatchNestedCSSRule(\"CSSGroupingRule\")) {\n    supportedNestedCSSRuleTypes.CSSGroupingRule = win.CSSGroupingRule;\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      // eslint-disable-next-line @typescript-eslint/unbound-method\n      insertRule: type.prototype.insertRule,\n      // eslint-disable-next-line @typescript-eslint/unbound-method\n      deleteRule: type.prototype.deleteRule\n    };\n    type.prototype.insertRule = new Proxy(\n      unmodifiedFunctions[typeKey].insertRule,\n      {\n        apply: callbackWrapper(\n          (target, thisArg, argumentsList) => {\n            const [rule, index] = argumentsList;\n            const { id, styleId } = getIdAndStyleId(\n              thisArg.parentStyleSheet,\n              mirror2,\n              stylesheetManager.styleMirror\n            );\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                      // defaults to 0\n                    ]\n                  }\n                ]\n              });\n            }\n            return target.apply(thisArg, argumentsList);\n          }\n        )\n      }\n    );\n    type.prototype.deleteRule = new Proxy(\n      unmodifiedFunctions[typeKey].deleteRule,\n      {\n        apply: callbackWrapper(\n          (target, thisArg, argumentsList) => {\n            const [index] = argumentsList;\n            const { id, styleId } = getIdAndStyleId(\n              thisArg.parentStyleSheet,\n              mirror2,\n              stylesheetManager.styleMirror\n            );\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    );\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({\n  mirror: mirror2,\n  stylesheetManager\n}, host) {\n  let hostId = null;\n  if (host.nodeName === \"#document\") hostId = mirror2.getId(host);\n  else hostId = mirror2.getId(host.host);\n  const patchTarget = host.nodeName === \"#document\" ? host.defaultView?.Document : host.ownerDocument?.defaultView?.ShadowRoot;\n  const originalPropertyDescriptor = patchTarget?.prototype ? Object.getOwnPropertyDescriptor(\n    patchTarget?.prototype,\n    \"adoptedStyleSheets\"\n  ) : void 0;\n  if (hostId === null || hostId === -1 || !patchTarget || !originalPropertyDescriptor)\n    return () => {\n    };\n  Object.defineProperty(host, \"adoptedStyleSheets\", {\n    configurable: originalPropertyDescriptor.configurable,\n    enumerable: originalPropertyDescriptor.enumerable,\n    get() {\n      return originalPropertyDescriptor.get?.call(this);\n    },\n    set(sheets) {\n      const result = originalPropertyDescriptor.set?.call(this, sheets);\n      if (hostId !== null && hostId !== -1) {\n        try {\n          stylesheetManager.adoptStyleSheets(sheets, hostId);\n        } catch (e2) {\n        }\n      }\n      return result;\n    }\n  });\n  return callbackWrapper(() => {\n    Object.defineProperty(host, \"adoptedStyleSheets\", {\n      configurable: originalPropertyDescriptor.configurable,\n      enumerable: originalPropertyDescriptor.enumerable,\n      // eslint-disable-next-line @typescript-eslint/unbound-method\n      get: originalPropertyDescriptor.get,\n      // eslint-disable-next-line @typescript-eslint/unbound-method\n      set: originalPropertyDescriptor.set\n    });\n  });\n}\nfunction initStyleDeclarationObserver({\n  styleDeclarationCb,\n  mirror: mirror2,\n  ignoreCSSAttributes,\n  stylesheetManager\n}, { win }) {\n  const setProperty = win.CSSStyleDeclaration.prototype.setProperty;\n  win.CSSStyleDeclaration.prototype.setProperty = new Proxy(setProperty, {\n    apply: callbackWrapper(\n      (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(\n          thisArg.parentRule?.parentStyleSheet,\n          mirror2,\n          stylesheetManager.styleMirror\n        );\n        if (id && id !== -1 || styleId && styleId !== -1) {\n          styleDeclarationCb({\n            id,\n            styleId,\n            set: {\n              property,\n              value,\n              priority\n            },\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            index: getNestedCSSRulePositions(thisArg.parentRule)\n          });\n        }\n        return target.apply(thisArg, argumentsList);\n      }\n    )\n  });\n  const removeProperty = win.CSSStyleDeclaration.prototype.removeProperty;\n  win.CSSStyleDeclaration.prototype.removeProperty = new Proxy(removeProperty, {\n    apply: callbackWrapper(\n      (target, thisArg, argumentsList) => {\n        const [property] = argumentsList;\n        if (ignoreCSSAttributes.has(property)) {\n          return removeProperty.apply(thisArg, [property]);\n        }\n        const { id, styleId } = getIdAndStyleId(\n          thisArg.parentRule?.parentStyleSheet,\n          mirror2,\n          stylesheetManager.styleMirror\n        );\n        if (id && id !== -1 || styleId && styleId !== -1) {\n          styleDeclarationCb({\n            id,\n            styleId,\n            remove: {\n              property\n            },\n            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n            index: getNestedCSSRulePositions(thisArg.parentRule)\n          });\n        }\n        return target.apply(thisArg, argumentsList);\n      }\n    )\n  });\n  return callbackWrapper(() => {\n    win.CSSStyleDeclaration.prototype.setProperty = setProperty;\n    win.CSSStyleDeclaration.prototype.removeProperty = removeProperty;\n  });\n}\nfunction initMediaInteractionObserver({\n  mediaInteractionCb,\n  blockClass,\n  blockSelector,\n  unblockSelector,\n  mirror: mirror2,\n  sampling,\n  doc\n}) {\n  const handler = callbackWrapper(\n    (type) => throttle$1(\n      callbackWrapper((event) => {\n        const target = getEventTarget(event);\n        if (!target || isBlocked(\n          target,\n          blockClass,\n          blockSelector,\n          unblockSelector,\n          true\n        )) {\n          return;\n        }\n        const { currentTime, volume, muted, playbackRate } = target;\n        mediaInteractionCb({\n          type,\n          id: mirror2.getId(target),\n          currentTime,\n          volume,\n          muted,\n          playbackRate\n        });\n      }),\n      sampling.media || 500\n    )\n  );\n  const handlers = [\n    on(\"play\", handler(MediaInteractions.Play), doc),\n    on(\"pause\", handler(MediaInteractions.Pause), doc),\n    on(\"seeked\", handler(MediaInteractions.Seeked), doc),\n    on(\"volumechange\", handler(MediaInteractions.VolumeChange), doc),\n    on(\"ratechange\", handler(MediaInteractions.RateChange), 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 = /* @__PURE__ */ new WeakMap();\n  const originalFontFace = win.FontFace;\n  win.FontFace = function FontFace2(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\" ? source : JSON.stringify(Array.from(new Uint8Array(source)))\n    });\n    return fontFace;\n  };\n  const restoreHandler = patch(\n    doc.fonts,\n    \"add\",\n    function(original) {\n      return function(fontFace) {\n        setTimeout$1(\n          callbackWrapper(() => {\n            const p = fontMap.get(fontFace);\n            if (p) {\n              fontCb(p);\n              fontMap.delete(fontFace);\n            }\n          }),\n          0\n        );\n        return original.apply(this, [fontFace]);\n      };\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 {\n    doc,\n    mirror: mirror2,\n    blockClass,\n    blockSelector,\n    unblockSelector,\n    selectionCb\n  } = param;\n  let collapsed = true;\n  const updateSelection = callbackWrapper(() => {\n    const selection = doc.getSelection();\n    if (!selection || collapsed && selection?.isCollapsed) return;\n    collapsed = selection.isCollapsed || false;\n    const ranges = [];\n    const count = selection.rangeCount || 0;\n    for (let i2 = 0; i2 < count; i2++) {\n      const range = selection.getRangeAt(i2);\n      const { startContainer, startOffset, endContainer, endOffset } = range;\n      const blocked = isBlocked(\n        startContainer,\n        blockClass,\n        blockSelector,\n        unblockSelector,\n        true\n      ) || isBlocked(\n        endContainer,\n        blockClass,\n        blockSelector,\n        unblockSelector,\n        true\n      );\n      if (blocked) continue;\n      ranges.push({\n        start: mirror2.getId(startContainer),\n        startOffset,\n        end: mirror2.getId(endContainer),\n        endOffset\n      });\n    }\n    selectionCb({ ranges });\n  });\n  updateSelection();\n  return on(\"selectionchange\", updateSelection);\n}\nfunction initCustomElementObserver({\n  doc,\n  customElementCb\n}) {\n  const win = doc.defaultView;\n  if (!win || !win.customElements) return () => {\n  };\n  const restoreHandler = patch(\n    win.customElements,\n    \"define\",\n    function(original) {\n      return function(name, constructor, options) {\n        try {\n          customElementCb({\n            define: {\n              name\n            }\n          });\n        } catch (e2) {\n        }\n        return original.apply(this, [name, constructor, options]);\n      };\n    }\n  );\n  return restoreHandler;\n}\nfunction initObservers(o2, _hooks = {}) {\n  const currentWindow = o2.doc.defaultView;\n  if (!currentWindow) {\n    return () => {\n    };\n  }\n  let mutationObserver;\n  if (o2.recordDOM) {\n    mutationObserver = initMutationObserver(o2, o2.doc);\n  }\n  const mousemoveHandler = initMoveObserver(o2);\n  const mouseInteractionHandler = initMouseInteractionObserver(o2);\n  const scrollHandler = initScrollObserver(o2);\n  const viewportResizeHandler = initViewportResizeObserver(o2, {\n    win: currentWindow\n  });\n  const inputHandler = initInputObserver(o2);\n  const mediaInteractionHandler = initMediaInteractionObserver(o2);\n  let styleSheetObserver = () => {\n  };\n  let adoptedStyleSheetObserver = () => {\n  };\n  let styleDeclarationObserver = () => {\n  };\n  let fontObserver = () => {\n  };\n  if (o2.recordDOM) {\n    styleSheetObserver = initStyleSheetObserver(o2, { win: currentWindow });\n    adoptedStyleSheetObserver = initAdoptedStyleSheetObserver(o2, o2.doc);\n    styleDeclarationObserver = initStyleDeclarationObserver(o2, {\n      win: currentWindow\n    });\n    if (o2.collectFonts) {\n      fontObserver = initFontObserver(o2);\n    }\n  }\n  const selectionObserver = initSelectionObserver(o2);\n  const customElementObserver = initCustomElementObserver(o2);\n  const pluginHandlers = [];\n  for (const plugin of o2.plugins) {\n    pluginHandlers.push(\n      plugin.observer(plugin.callback, currentWindow, plugin.options)\n    );\n  }\n  return callbackWrapper(() => {\n    mutationBuffers.forEach((b) => b.reset());\n    mutationObserver?.disconnect();\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(\n    typeof window[prop] !== \"undefined\" && // Note: Generally, this check _shouldn't_ be necessary\n    // However, in some scenarios (e.g. jsdom) this can sometimes fail, so we check for it here\n    window[prop].prototype && \"insertRule\" in window[prop].prototype && \"deleteRule\" in window[prop].prototype\n  );\n}\nclass CrossOriginIframeMirror {\n  constructor(generateIdFn) {\n    this.generateIdFn = generateIdFn;\n    this.iframeIdToRemoteIdMap = /* @__PURE__ */ new WeakMap();\n    this.iframeRemoteIdToIdMap = /* @__PURE__ */ 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(\n      (id) => this.getId(iframe, id, idToRemoteIdMap, remoteIdToIdMap)\n    );\n  }\n  getRemoteId(iframe, id, map) {\n    const remoteIdToIdMap = map || this.getRemoteIdToIdMap(iframe);\n    if (typeof id !== \"number\") return id;\n    const remoteId = remoteIdToIdMap.get(id);\n    if (!remoteId) 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 = /* @__PURE__ */ new WeakMap();\n      this.iframeRemoteIdToIdMap = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ new Map();\n      this.iframeRemoteIdToIdMap.set(iframe, remoteIdToIdMap);\n    }\n    return remoteIdToIdMap;\n  }\n}\nclass IframeManagerNoop {\n  constructor() {\n    this.crossOriginIframeMirror = new CrossOriginIframeMirror(genId);\n    this.crossOriginIframeRootIdMap = /* @__PURE__ */ new WeakMap();\n  }\n  addIframe() {\n  }\n  addLoadListener() {\n  }\n  attachIframe() {\n  }\n}\nclass IframeManager {\n  constructor(options) {\n    this.iframes = /* @__PURE__ */ new WeakMap();\n    this.crossOriginIframeMap = /* @__PURE__ */ new WeakMap();\n    this.crossOriginIframeMirror = new CrossOriginIframeMirror(genId);\n    this.crossOriginIframeRootIdMap = /* @__PURE__ */ 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(\n      this.stylesheetManager.styleMirror.generateId.bind(\n        this.stylesheetManager.styleMirror\n      )\n    );\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    if (this.recordCrossOriginIframes)\n      iframeEl.contentWindow?.addEventListener(\n        \"message\",\n        this.handleMessage.bind(this)\n      );\n    this.loadListener?.(iframeEl);\n    const iframeDoc = getIFrameContentDocument(iframeEl);\n    if (iframeDoc && iframeDoc.adoptedStyleSheets && iframeDoc.adoptedStyleSheets.length > 0)\n      this.stylesheetManager.adoptStyleSheets(\n        iframeDoc.adoptedStyleSheets,\n        this.mirror.getId(iframeDoc)\n      );\n  }\n  handleMessage(message) {\n    const crossOriginMessageEvent = message;\n    if (crossOriginMessageEvent.data.type !== \"rrweb\" || // To filter out the rrweb messages which are forwarded by some sites.\n    crossOriginMessageEvent.origin !== crossOriginMessageEvent.data.origin)\n      return;\n    const iframeSourceWindow = message.source;\n    if (!iframeSourceWindow) return;\n    const iframeEl = this.crossOriginIframeMap.get(message.source);\n    if (!iframeEl) return;\n    const transformedEvent = this.transformCrossOriginEvent(\n      iframeEl,\n      crossOriginMessageEvent.data.event\n    );\n    if (transformedEvent)\n      this.wrappedEmit(\n        transformedEvent,\n        crossOriginMessageEvent.data.isCheckout\n      );\n  }\n  transformCrossOriginEvent(iframeEl, e2) {\n    switch (e2.type) {\n      case EventType.FullSnapshot: {\n        this.crossOriginIframeMirror.reset(iframeEl);\n        this.crossOriginIframeStyleMirror.reset(iframeEl);\n        this.replaceIdOnNode(e2.data.node, iframeEl);\n        const rootId = e2.data.node.id;\n        this.crossOriginIframeRootIdMap.set(iframeEl, rootId);\n        this.patchRootIdOnNode(e2.data.node, rootId);\n        return {\n          timestamp: e2.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: e2.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 e2;\n      }\n      case EventType.Custom: {\n        this.replaceIds(\n          e2.data.payload,\n          iframeEl,\n          [\"id\", \"parentId\", \"previousId\", \"nextId\"]\n        );\n        return e2;\n      }\n      case EventType.IncrementalSnapshot: {\n        switch (e2.data.source) {\n          case IncrementalSource.Mutation: {\n            e2.data.adds.forEach((n2) => {\n              this.replaceIds(n2, iframeEl, [\n                \"parentId\",\n                \"nextId\",\n                \"previousId\"\n              ]);\n              this.replaceIdOnNode(n2.node, iframeEl);\n              const rootId = this.crossOriginIframeRootIdMap.get(iframeEl);\n              rootId && this.patchRootIdOnNode(n2.node, rootId);\n            });\n            e2.data.removes.forEach((n2) => {\n              this.replaceIds(n2, iframeEl, [\"parentId\", \"id\"]);\n            });\n            e2.data.attributes.forEach((n2) => {\n              this.replaceIds(n2, iframeEl, [\"id\"]);\n            });\n            e2.data.texts.forEach((n2) => {\n              this.replaceIds(n2, iframeEl, [\"id\"]);\n            });\n            return e2;\n          }\n          case IncrementalSource.Drag:\n          case IncrementalSource.TouchMove:\n          case IncrementalSource.MouseMove: {\n            e2.data.positions.forEach((p) => {\n              this.replaceIds(p, iframeEl, [\"id\"]);\n            });\n            return e2;\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(e2.data, iframeEl, [\"id\"]);\n            return e2;\n          }\n          case IncrementalSource.StyleSheetRule:\n          case IncrementalSource.StyleDeclaration: {\n            this.replaceIds(e2.data, iframeEl, [\"id\"]);\n            this.replaceStyleIds(e2.data, iframeEl, [\"styleId\"]);\n            return e2;\n          }\n          case IncrementalSource.Font: {\n            return e2;\n          }\n          case IncrementalSource.Selection: {\n            e2.data.ranges.forEach((range) => {\n              this.replaceIds(range, iframeEl, [\"start\", \"end\"]);\n            });\n            return e2;\n          }\n          case IncrementalSource.AdoptedStyleSheet: {\n            this.replaceIds(e2.data, iframeEl, [\"id\"]);\n            this.replaceStyleIds(e2.data, iframeEl, [\"styleIds\"]);\n            e2.data.styles?.forEach((style) => {\n              this.replaceStyleIds(style, iframeEl, [\"styleId\"]);\n            });\n            return e2;\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\") continue;\n      if (Array.isArray(obj[key])) {\n        obj[key] = iframeMirror.getIds(\n          iframeEl,\n          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$2.Document && !node.rootId) node.rootId = rootId;\n    if (\"childNodes\" in node) {\n      node.childNodes.forEach((child) => {\n        this.patchRootIdOnNode(child, rootId);\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 = /* @__PURE__ */ 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)) return;\n    if (this.shadowDoms.has(shadowRoot)) return;\n    this.shadowDoms.add(shadowRoot);\n    this.bypassOptions.canvasManager.addShadowRoot(shadowRoot);\n    const observer = initMutationObserver(\n      {\n        ...this.bypassOptions,\n        doc,\n        mutationCb: this.mutationCb,\n        mirror: this.mirror,\n        shadowDomManager: this\n      },\n      shadowRoot\n    );\n    this.restoreHandlers.push(() => observer.disconnect());\n    this.restoreHandlers.push(\n      initScrollObserver({\n        ...this.bypassOptions,\n        scrollCb: this.scrollCb,\n        // https://gist.github.com/praveenpuglia/0832da687ed5a5d7a0907046c9ef1813\n        // scroll is not allowed to pass the boundary, so we need to listen the shadow document\n        doc: shadowRoot,\n        mirror: this.mirror\n      })\n    );\n    setTimeout$1(() => {\n      if (shadowRoot.adoptedStyleSheets && shadowRoot.adoptedStyleSheets.length > 0)\n        this.bypassOptions.stylesheetManager.adoptStyleSheets(\n          shadowRoot.adoptedStyleSheets,\n          this.mirror.getId(shadowRoot.host)\n        );\n      this.restoreHandlers.push(\n        initAdoptedStyleSheetObserver(\n          {\n            mirror: this.mirror,\n            stylesheetManager: this.bypassOptions.stylesheetManager\n          },\n          shadowRoot\n        )\n      );\n    }, 0);\n  }\n  /**\n   * Monkey patch 'attachShadow' of an IFrameElement to observe newly added shadow doms.\n   */\n  observeAttachShadow(iframeElement) {\n    const iframeDoc = getIFrameContentDocument(iframeElement);\n    const iframeWindow = getIFrameContentWindow(iframeElement);\n    if (!iframeDoc || !iframeWindow) return;\n    this.patchAttachShadow(\n      iframeWindow.Element,\n      iframeDoc\n    );\n  }\n  /**\n   * Patch 'attachShadow' to observe newly added shadow doms.\n   */\n  patchAttachShadow(element, doc) {\n    const manager = this;\n    this.restoreHandlers.push(\n      patch(\n        element.prototype,\n        \"attachShadow\",\n        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    );\n  }\n  reset() {\n    this.restoreHandlers.forEach((handler) => {\n      try {\n        handler();\n      } catch (e2) {\n      }\n    });\n    this.restoreHandlers = [];\n    this.shadowDoms = /* @__PURE__ */ new WeakSet();\n    this.bypassOptions.canvasManager.resetShadowRoots();\n  }\n}\nvar chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\nvar lookup = typeof Uint8Array === \"undefined\" ? [] : new Uint8Array(256);\nfor (var i$1 = 0; i$1 < chars.length; i$1++) {\n  lookup[chars.charCodeAt(i$1)] = i$1;\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}\nclass StylesheetManager {\n  constructor(options) {\n    this.trackedLinkElements = /* @__PURE__ */ 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.attributes\n          }\n        ]\n      });\n    this.trackLinkElement(linkEl);\n  }\n  trackLinkElement(linkEl) {\n    if (this.trackedLinkElements.has(linkEl)) return;\n    this.trackedLinkElements.add(linkEl);\n    this.trackStylesheetInLinkElement(linkEl);\n  }\n  adoptStyleSheets(sheets, hostId) {\n    if (sheets.length === 0) 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, (r2, index) => ({\n            rule: stringifyRule(r2),\n            index\n          }))\n        });\n      } else styleId = this.styleMirror.getId(sheet);\n      adoptedStyleSheetData.styleIds.push(styleId);\n    }\n    if (styles.length > 0) adoptedStyleSheetData.styles = styles;\n    this.adoptedStyleSheetCb(adoptedStyleSheetData);\n  }\n  reset() {\n    this.styleMirror.reset();\n    this.trackedLinkElements = /* @__PURE__ */ new WeakSet();\n  }\n  // TODO: take snapshot on stylesheet reload by applying event listener\n  trackStylesheetInLinkElement(_linkEl) {\n  }\n}\nclass ProcessedNodeManager {\n  constructor() {\n    this.nodeMap = /* @__PURE__ */ 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 = /* @__PURE__ */ new WeakMap();\n        this.active = false;\n      });\n    }\n    this.nodeMap.set(node, (this.nodeMap.get(node) || /* @__PURE__ */ new Set()).add(buffer));\n  }\n  destroy() {\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 = cleanFrame.contentWindow?.Array.from || Array.from;\n    document.body.removeChild(cleanFrame);\n  }\n} catch (err) {\n  console.debug(\"Unable to override Array.from\", err);\n}\nconst mirror = createMirror$2();\nfunction record(options = {}) {\n  const {\n    emit,\n    checkoutEveryNms,\n    checkoutEveryNth,\n    blockClass = \"rr-block\",\n    blockSelector = null,\n    unblockSelector = null,\n    ignoreClass = \"rr-ignore\",\n    ignoreSelector = null,\n    maskAllText = false,\n    maskTextClass = \"rr-mask\",\n    unmaskTextClass = null,\n    maskTextSelector = null,\n    unmaskTextSelector = null,\n    inlineStylesheet = true,\n    maskAllInputs,\n    maskInputOptions: _maskInputOptions,\n    slimDOMOptions: _slimDOMOptions,\n    maskAttributeFn,\n    maskInputFn,\n    maskTextFn,\n    maxCanvasSize = null,\n    packFn,\n    sampling = {},\n    dataURLOptions = {},\n    mousemoveWait,\n    recordDOM = true,\n    recordCanvas = false,\n    recordCrossOriginIframes = false,\n    recordAfter = options.recordAfter === \"DOMContentLoaded\" ? options.recordAfter : \"load\",\n    userTriggeredOnInput = false,\n    collectFonts = false,\n    inlineImages = false,\n    plugins,\n    keepIframeSrcFn = () => false,\n    ignoreCSSAttributes = /* @__PURE__ */ new Set([]),\n    errorHandler: errorHandler2,\n    onMutation,\n    getCanvasManager\n  } = options;\n  registerErrorHandler(errorHandler2);\n  const inEmittingFrame = recordCrossOriginIframes ? window.parent === window : true;\n  let passEmitsToParent = false;\n  if (!inEmittingFrame) {\n    try {\n      if (window.parent.document) {\n        passEmitsToParent = false;\n      }\n    } catch (e2) {\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 !== void 0 && sampling.mousemove === void 0) {\n    sampling.mousemove = mousemoveWait;\n  }\n  mirror.reset();\n  const maskInputOptions = maskAllInputs === true ? {\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  } : _maskInputOptions !== void 0 ? _maskInputOptions : {};\n  const slimDOMOptions = _slimDOMOptions === true || _slimDOMOptions === \"all\" ? {\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    // the following are off for slimDOMOptions === true,\n    // as they destroy some (hidden) info:\n    headMetaAuthorship: _slimDOMOptions === \"all\",\n    headMetaDescKeywords: _slimDOMOptions === \"all\"\n  } : _slimDOMOptions ? _slimDOMOptions : {};\n  polyfill$1();\n  let lastFullSnapshotEvent;\n  let incrementalSnapshotCount = 0;\n  const eventProcessor = (e2) => {\n    for (const plugin of plugins || []) {\n      if (plugin.eventProcessor) {\n        e2 = plugin.eventProcessor(e2);\n      }\n    }\n    if (packFn && // Disable packing events which will be emitted to parent frames.\n    !passEmitsToParent) {\n      e2 = packFn(e2);\n    }\n    return e2;\n  };\n  wrappedEmit = (r2, isCheckout) => {\n    const e2 = r2;\n    e2.timestamp = nowTimestamp();\n    if (mutationBuffers[0]?.isFrozen() && e2.type !== EventType.FullSnapshot && !(e2.type === EventType.IncrementalSnapshot && e2.data.source === IncrementalSource.Mutation)) {\n      mutationBuffers.forEach((buf) => buf.unfreeze());\n    }\n    if (inEmittingFrame) {\n      emit?.(eventProcessor(e2), isCheckout);\n    } else if (passEmitsToParent) {\n      const message = {\n        type: \"rrweb\",\n        event: eventProcessor(e2),\n        origin: window.location.origin,\n        isCheckout\n      };\n      window.parent.postMessage(message, \"*\");\n    }\n    if (e2.type === EventType.FullSnapshot) {\n      lastFullSnapshotEvent = e2;\n      incrementalSnapshotCount = 0;\n    } else if (e2.type === EventType.IncrementalSnapshot) {\n      if (e2.data.source === IncrementalSource.Mutation && e2.data.isAttachIframe) {\n        return;\n      }\n      incrementalSnapshotCount++;\n      const exceedCount = checkoutEveryNth && incrementalSnapshotCount >= checkoutEveryNth;\n      const exceedTime = checkoutEveryNms && lastFullSnapshotEvent && e2.timestamp - lastFullSnapshotEvent.timestamp > checkoutEveryNms;\n      if (exceedCount || exceedTime) {\n        takeFullSnapshot2(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 = (a2) => wrappedEmit({\n    type: EventType.IncrementalSnapshot,\n    data: {\n      source: IncrementalSource.AdoptedStyleSheet,\n      ...a2\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__ ? new IframeManagerNoop() : new IframeManager({\n    mirror,\n    mutationCb: wrappedMutationEmit,\n    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(\n    getCanvasManager,\n    {\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: errorHandler2\n    }\n  );\n  const shadowDomManager = typeof __RRWEB_EXCLUDE_SHADOW_DOM__ === \"boolean\" && __RRWEB_EXCLUDE_SHADOW_DOM__ ? new ShadowDomManagerNoop() : 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 takeFullSnapshot2 = (isCheckout = false) => {\n    if (!recordDOM) {\n      return;\n    }\n    wrappedEmit(\n      {\n        type: EventType.Meta,\n        data: {\n          href: window.location.href,\n          width: getWindowWidth(),\n          height: getWindowHeight()\n        }\n      },\n      isCheckout\n    );\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: (n2) => {\n        if (isSerializedIframe(n2, mirror)) {\n          iframeManager.addIframe(n2);\n        }\n        if (isSerializedStylesheet(n2, mirror)) {\n          stylesheetManager.trackLinkElement(n2);\n        }\n        if (hasShadowRoot(n2)) {\n          shadowDomManager.addShadowRoot(n2.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(\n        document.adoptedStyleSheets,\n        mirror.getId(document)\n      );\n  };\n  _takeFullSnapshot = takeFullSnapshot2;\n  try {\n    const handlers = [];\n    const observe = (doc) => {\n      return callbackWrapper(initObservers)(\n        {\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: (v2) => wrappedEmit({\n            type: EventType.IncrementalSnapshot,\n            data: {\n              source: IncrementalSource.Input,\n              ...v2\n            }\n          }),\n          mediaInteractionCb: (p) => wrappedEmit({\n            type: EventType.IncrementalSnapshot,\n            data: {\n              source: IncrementalSource.MediaInteraction,\n              ...p\n            }\n          }),\n          styleSheetRuleCb: (r2) => wrappedEmit({\n            type: EventType.IncrementalSnapshot,\n            data: {\n              source: IncrementalSource.StyleSheetRule,\n              ...r2\n            }\n          }),\n          styleDeclarationCb: (r2) => wrappedEmit({\n            type: EventType.IncrementalSnapshot,\n            data: {\n              source: IncrementalSource.StyleDeclaration,\n              ...r2\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: (c2) => {\n            wrappedEmit({\n              type: EventType.IncrementalSnapshot,\n              data: {\n                source: IncrementalSource.CustomElement,\n                ...c2\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: plugins?.filter((p) => p.observer)?.map((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      );\n    };\n    iframeManager.addLoadListener((iframeEl) => {\n      try {\n        handlers.push(observe(iframeEl.contentDocument));\n      } catch (error) {\n        console.warn(error);\n      }\n    });\n    const init = () => {\n      takeFullSnapshot2();\n      handlers.push(observe(document));\n    };\n    if (document.readyState === \"interactive\" || document.readyState === \"complete\") {\n      init();\n    } else {\n      handlers.push(\n        on(\"DOMContentLoaded\", () => {\n          wrappedEmit({\n            type: EventType.DomContentLoaded,\n            data: {}\n          });\n          if (recordAfter === \"DOMContentLoaded\") init();\n        })\n      );\n      handlers.push(\n        on(\n          \"load\",\n          () => {\n            wrappedEmit({\n              type: EventType.Load,\n              data: {}\n            });\n            if (recordAfter === \"load\") init();\n          },\n          window\n        )\n      );\n    }\n    return () => {\n      handlers.forEach((h) => h());\n      processedNodeManager.destroy();\n      _takeFullSnapshot = void 0;\n      unregisterErrorHandler();\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 ? getCanvasManagerFn(options) : new CanvasManagerNoop();\n  } catch {\n    console.warn(\"Unable to initialize CanvasManager\");\n    return new CanvasManagerNoop();\n  }\n}\nvar n;\n!function(t2) {\n  t2[t2.NotStarted = 0] = \"NotStarted\", t2[t2.Running = 1] = \"Running\", t2[t2.Stopped = 2] = \"Stopped\";\n}(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 {\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 = /* @__PURE__ */ ((NodeType2) => {\n  NodeType2[NodeType2[\"Document\"] = 0] = \"Document\";\n  NodeType2[NodeType2[\"DocumentType\"] = 1] = \"DocumentType\";\n  NodeType2[NodeType2[\"Element\"] = 2] = \"Element\";\n  NodeType2[NodeType2[\"Text\"] = 3] = \"Text\";\n  NodeType2[NodeType2[\"CDATA\"] = 4] = \"CDATA\";\n  NodeType2[NodeType2[\"Comment\"] = 5] = \"Comment\";\n  return NodeType2;\n})(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?.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?.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?.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]),s=new t([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),a=function(t,e){for(var i=new n(31),s=0;s<31;++s)i[s]=e+=1<<t[s-1];var a=new r(i[30]);for(s=1;s<30;++s)for(var o=i[s];o<i[s+1];++o)a[o]=o-i[s]<<5|s;return{b:i,r:a}},o=a(e,2),h=o.b,f=o.r;h[28]=258,f[258]=28;for(var l=a(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,s=0,a=new n(r);s<i;++s)t[s]&&++a[t[s]-1];var o,h=new n(r);for(s=1;s<r;++s)h[s]=h[s-1]+a[s-1]<<1;if(e){o=new n(1<<r);var f=15-r;for(s=0;s<i;++s)if(t[s])for(var l=s<<4|t[s],c=r-t[s],v=h[t[s]-1]++<<c,d=v|(1<<c)-1;v<=d;++v)o[u[v]>>f]=l}else for(o=new n(i),s=0;s<i;++s)t[s]&&(o[s]=u[h[t[s]-1]++]>>15-t[s]);return o},p=new t(288);for(c=0;c<144;++c)p[c]=8;for(c=144;c<256;++c)p[c]=9;for(c=256;c<280;++c)p[c]=7;for(c=280;c<288;++c)p[c]=8;var g=new t(32);for(c=0;c<32;++c)g[c]=5;var w=d(p,9,0),y=d(g,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=[],s=0;s<r.length;++s)r[s]&&i.push({s:s,f:r[s]});var a=i.length,o=i.slice();if(!a)return{t:F,l:0};if(1==a){var h=new t(i[0].s+1);return h[i[0].s]=1,{t:h,l:1}}i.sort((function(t,n){return t.f-n.f})),i.push({s:-1,f:25001});var f=i[0],l=i[1],u=0,c=1,v=2;for(i[0]={s:-1,f:f.f+l.f,l:f,r:l};c!=a-1;)f=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:f.f+l.f,l:f,r:l};var d=o[0].s;for(s=1;s<a;++s)o[s].s>d&&(d=o[s].s);var p=new n(d+1),g=A(i[c-1],p,0);if(g>e){s=0;var w=0,y=g-e,m=1<<y;for(o.sort((function(t,n){return p[n.s]-p[t.s]||t.f-n.f}));s<a;++s){var b=o[s].s;if(!(p[b]>e))break;w+=m-(1<<g-p[b]),p[b]=e}for(w>>=y;w>0;){var M=o[s].s;p[M]<e?w-=1<<e-p[M]++-1:++s}for(;s>=0&&w;--s){var E=o[s].s;p[E]==e&&(--p[E],++w)}g=e}return{t:new t(p),l:g}},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,s=t[0],a=1,o=function(t){e[i++]=t},h=1;h<=r;++h)if(t[h]==s&&h!=r)++a;else{if(!s&&a>2){for(;a>138;a-=138)o(32754);a>2&&(o(a>10?a-11<<5|28690:a-3<<5|12305),a=0)}else if(a>3){for(o(s),--a;a>6;a-=6)o(8304);a>2&&(o(a-3<<5|8208),a=0)}for(;a--;)o(s);a=1,s=t[h]}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 s=0;s<e;++s)t[i+s+4]=r[s];return 8*(i+4+e)},U=function(t,r,a,o,h,f,l,u,c,v,m){z(r,m++,a),++h[256];for(var b=x(h,15),M=b.t,E=b.l,A=x(f,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[s[K-1]];--K);var N,P,Q,R,V=v+5<<3,W=T(h,p)+T(f,g)+l,X=T(h,M)+T(f,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[s[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=w,P=p,Q=y,R=g;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,s=0|r.length,a=0;a!=s;){for(var o=Math.min(a+2655,s);a<o;++a)i+=e+=r[a];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(s,a,o,h,u){if(!u&&(u={l:1},a.dictionary)){var c=a.dictionary.subarray(-32768),v=new t(c.length+s.length);v.set(c),v.set(s,c.length),s=v,u.w=c.length}return function(s,a,o,h,u,c){var v=c.z||s.length,d=new t(h+v+5*(1+Math.ceil(v/7e3))+u),p=d.subarray(h,d.length-u),g=c.l,w=7&(c.r||0);if(a){w&&(p[0]=c.r>>3);for(var y=C[a-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(s[t]^s[t+1]<<A^s[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||!g)){w=U(s,p,0,F,I,S,O,q,G,j-G,w),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(s[j+Q]==s[j+Q-W]){for(var $=0;$<Z&&s[j+$]==s[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|f[Q]<<18|l[R];var it=31&f[Q],st=31&l[R];O+=e[it]+i[st],++I[257+it],++S[st],B=j+Q,++L}else F[q++]=s[j],++I[s[j]]}}for(j=Math.max(j,B);j<v;++j)F[q++]=s[j],++I[s[j]];w=U(s,p,g,F,I,S,O,q,G,j-G,w),g||(c.r=7&w|p[w/8|0]<<3,w-=7,c.h=x,c.p=_,c.i=j,c.w=B)}else{for(j=c.w||0;j<v+g;j+=65535){var at=j+65535;at>=v&&(p[w/8|0]=g,at=v),w=k(p,w+1,s.subarray(j,at))}c.i=v}return b(d,0,h+m(w)+u)}(s,null==a.level?6:a.level,null==a.mem?u.l?Math.ceil(1.5*Math.max(8,Math.min(13,Math.log(s.length)))):20:12+a.mem,o,h,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 s=this.b.length-this.s.z;this.b.set(n.subarray(0,s),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(s),32768),this.s.z=n.length-s+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.prototype.flush=function(){this.ondata||E(5),this.s.l&&E(4),this.p(this.b,!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.prototype.flush=function(){G.prototype.flush.call(this)},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)),s=0,a=function(t){i[s++]=t},o=0;o<e;++o){if(s+5>i.length){var h=new t(s+8+(e-o<<1));h.set(i),i=h}var f=n.charCodeAt(o);f<128||r?a(f):f<2048?(a(192|f>>6),a(128|63&f)):f>55295&&f<57344?(a(240|(f=65536+(1047552&f)|1023&n.charCodeAt(++o))>>18),a(128|f>>12&63),a(128|f>>6&63),a(128|63&f)):(a(224|f>>12),a(128|f>>6&63),a(128|63&f))}return b(i,0,s)}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),s=i.length;return q(i,n),j(i,s-8,r.d()),j(i,s-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 {\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 {\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 {\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 {\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?.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?.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 = 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?.arguments;\n\n  if (!Array.isArray(args) || args.length === 0) {\n    return createBreadcrumb(breadcrumb);\n  }\n\n  let isTruncated = false;\n\n  // Avoid giant args captures\n  const normalizedArgs = args.map(arg => {\n    if (!arg) {\n      return arg;\n    }\n    if (typeof arg === 'string') {\n      if (arg.length > CONSOLE_ARG_MAX_SIZE) {\n        isTruncated = true;\n        return `${arg.slice(0, CONSOLE_ARG_MAX_SIZE)}…`;\n      }\n\n      return arg;\n    }\n    if (typeof arg === 'object') {\n      try {\n        const normalizedArg = normalize(arg, 7);\n        const stringified = JSON.stringify(normalizedArg);\n        if (stringified.length > CONSOLE_ARG_MAX_SIZE) {\n          isTruncated = true;\n          // We use the pretty printed JSON string here as a base\n          return `${JSON.stringify(normalizedArg, null, 2).slice(0, CONSOLE_ARG_MAX_SIZE)}…`;\n        }\n        return normalizedArg;\n      } catch {\n        // fall back to default\n      }\n    }\n\n    return arg;\n  });\n\n  return createBreadcrumb({\n    ...breadcrumb,\n    data: {\n      ...breadcrumb.data,\n      arguments: normalizedArgs,\n      ...(isTruncated ? { _meta: { warnings: ['CONSOLE_ARG_TRUNCATED'] } } : {}),\n    },\n  });\n}\n\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?.__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 {\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/** 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: {\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?.length) {\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 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 {\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, logger);\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 = 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 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, logger) : [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 {\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 {\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?.xhr;\n}\n\nfunction _isFetchHint(hint) {\n  return hint?.response;\n}\n\n/**\n * Add global listeners that cannot be removed.\n */\nfunction addGlobalListeners(\n  replay,\n  { autoFlushOnFeedback },\n) {\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 attach the replay id to the feedback event\n    client.on('beforeSendFeedback', async (feedbackEvent, options) => {\n      const replayId = replay.getSessionId();\n      if (options?.includeReplay && replay.isEnabled() && replayId && feedbackEvent.contexts?.feedback) {\n        // In case the feedback is sent via API and not through our widget, we want to flush replay\n        if (feedbackEvent.contexts.feedback.source === 'api' && autoFlushOnFeedback) {\n          await replay.flush();\n        }\n        feedbackEvent.contexts.feedback.replay_id = replayId;\n      }\n    });\n\n    if (autoFlushOnFeedback) {\n      client.on('openFeedbackWidget', async () => {\n        await replay.flush();\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?.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?.userAgent ?? '') ||\n    (/Macintosh/i.test(NAVIGATOR?.userAgent ?? '') && NAVIGATOR?.maxTouchPoints && 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?.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' &&\n    client['_integrations'] !== null &&\n    !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  client.emit('postprocessEvent', preparedEvent, eventHint);\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?.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?.getTransport();\n  const dsn = 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');\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 {\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 {\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  /**\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\n  /**\n   * Handle when page is blurred\n   */\n\n  /**\n   * Handle when page is focused\n   */\n\n  /** Ensure page remains active when a key is pressed. */\n\n   constructor({\n    options,\n    recordingOptions,\n  }\n\n) {\n    this.eventBuffer = null;\n    this.performanceEntries = [];\n    this.replayPerformanceEntries = [];\n    this.recordingMode = 'session';\n    this.timeouts = {\n      sessionIdlePause: SESSION_IDLE_PAUSE_DURATION,\n      sessionIdleExpire: SESSION_IDLE_EXPIRE_DURATION,\n    } ;\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    // We set these handler properties as class properties, to make binding/unbinding them easier\n    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    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    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    this._handleKeyboardEvent = (event) => {\n      handleKeyboardEvent(this, event);\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.bind(this),\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?.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?.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, { autoFlushOnFeedback: this._options._experiments.autoFlushOnFeedback });\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   * 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?.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   async _flush({\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   _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 */\nclass Replay  {\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';\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      // experimental support for recording iframes from different origins\n      recordCrossOriginIframes: Boolean(_experiments.recordCrossOriginIframes),\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?.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?.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 {\n      // ignore errors here\n    }\n    /* eslint-enable @typescript-eslint/no-non-null-assertion */\n  }\n}\n\n/** Parse Replay-related options from SDK options */\nfunction loadReplayOptionsFromClient(initialOptions, client) {\n  const opt = client.getOptions() ;\n\n  const finalOptions = {\n    sessionSampleRate: 0,\n    errorSampleRate: 0,\n    ...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?.getIntegrationByName('Replay');\n}\n\nexport { getReplay, replayIntegration };\n//# sourceMappingURL=index.js.map\n"],"names":["WINDOW","GLOBAL_OBJ","REPLAY_SESSION_KEY","REPLAY_EVENT_NAME","UNABLE_TO_SEND_REPLAY","NETWORK_BODY_MAX_SIZE","CONSOLE_ARG_MAX_SIZE","REPLAY_MAX_EVENT_BUFFER_SIZE","MAX_REPLAY_DURATION","__defProp$1","Object","defineProperty","__publicField$1","obj","key","value","enumerable","configurable","writable","__defNormalProp$1","NodeType$2","NodeType2","isShadowRoot","n2","host","Boolean","shadowRoot","isNativeShadowDom","prototype","toString","call","stringifyStylesheet","s2","rules2","rules","cssRules","cssText","Array","from","stringifyRule","join","includes","replace","error","rule","importStringified","isCSSImportRule","styleSheet","split","length","statement","JSON","stringify","href","layerName","push","supportsText","media","mediaText","escapeImportStatement","isCSSStyleRule","needsSafariColonFix","selectorText","needsAllFix","style","styles","i2","styleDeclaration","attribute","isImportant","getPropertyPriority","getPropertyValue","fixAllCssProperty","cssStringified","regex","fixSafariColons","Mirror","constructor","this","Map","WeakMap","getId","id","getMeta","getNode","idNodeMap","get","getIds","keys","nodeMetaMap","removeNodeFromMap","delete","childNodes","forEach","childNode","has","hasNode","node","add","meta","set","oldNode","reset","shouldMaskInput","maskInputOptions","tagName","type","toLowerCase","maskInputValue","isMasked","element","maskInputFn","text","repeat","str","toUpperCase","ORIGINAL_ATTRIBUTE_NAME","getInputType","hasAttribute","getInputValue","el","getAttribute","extractFileExtension","path","baseURL","url","URL","window","location","err","match","pathname","cachedImplementations$1","getImplementation$1","name","cached","document2","document","impl","createElement","sandbox","hidden","head","appendChild","contentWindow","removeChild","e2","bind","setTimeout$2","rest","clearTimeout$1","getIframeContentDocument","iframe","contentDocument","_id","tagNameRegex","RegExp","IGNORED_NODE","genId","canvasService","canvasCtx","URL_IN_CSS_REF","URL_PROTOCOL_MATCH","URL_WWW_MATCH","DATA_URI","absoluteToStylesheet","origin","quote1","path1","quote2","path2","path3","filePath","maybeQuote","test","indexOf","slice","extractOrigin","stack","parts","pop","part","SRCSET_NOT_SPACES","SRCSET_COMMAS_OR_SPACES","cachedDocument","absoluteToDoc","doc","attributeValue","trim","getHref","isSVGElement","ownerSVGElement","customHref","a2","startsWith","setAttribute","transformAttribute","maskAttributeFn","pos","collectCharacters","regEx","chars2","exec","substring","output","descriptorsStr","inParens","c2","charAt","getAbsoluteSrcsetString","ignoreAttribute","_value","_isBlockedElement","blockClass","blockSelector","unblockSelector","matches","classList","contains","eIndex","className","distanceToMatch","matchPredicate","limit","Infinity","distance","nodeType","ELEMENT_NODE","parentNode","createMatchPredicate","selector","elementClassMatchesRegex","needMaskingText","maskTextClass","maskTextSelector","unmaskTextClass","unmaskTextSelector","maskAllText","parentElement","autocomplete","maskDistance","unmaskDistance","serializeNode","options","mirror","mirror2","inlineStylesheet","maskTextFn","dataURLOptions","inlineImages","recordCanvas","keepIframeSrcFn","newlyAddedElement","rootId","docId","getRootId","DOCUMENT_NODE","compatMode","Document","DOCUMENT_TYPE_NODE","DocumentType","publicId","systemId","needBlock","HTMLFormElement","processedTagName","getValidTagName$1","attributes2","len","attributes","attr","stylesheet","styleSheets","find","rel","crossorigin","_cssText","sheet","innerText","textContent","checked","forceMask","selected","__context","canvas","ctx","getContext","x","width","y","height","getImageData","originalGetImageData","Uint32Array","Math","min","data","buffer","some","pixel","is2DCanvasBlank","rr_dataURL","toDataURL","quality","canvasDataURL","blankCanvas","image","imageSrc","currentSrc","priorCrossOrigin","crossOrigin","recordInlineImage","removeEventListener","naturalWidth","naturalHeight","drawImage","complete","addEventListener","console","warn","removeAttribute","rr_mediaState","paused","rr_mediaCurrentTime","currentTime","scrollLeft","rr_scrollLeft","scrollTop","rr_scrollTop","getBoundingClientRect","class","rr_width","rr_height","src","rr_src","isCustomElement","customElements","Element","isSVG","isCustom","serializeElementNode","TEXT_NODE","parentTagName","isStyle","isScript","isTextarea","nextSibling","previousSibling","textarea","Text","serializeTextNode","CDATA_SECTION_NODE","CDATA","COMMENT_NODE","Comment","lowerIfExists","maybeAttr","serializeNodeWithId","skipChild","slimDOMOptions","onSerialize","onIframeLoad","iframeLoadTimeout","onStylesheetLoad","stylesheetLoadTimeout","preserveWhiteSpace","_serializedNode","sn","comment","script","headFavicon","headMetaDescKeywords","headMetaSocial","property","headMetaRobots","headMetaHttpEquiv","headMetaAuthorship","headMetaVerification","slimDOMExcluded","serializedNode2","assign","recordChild","isShadowHost","headWhitespace","bypassOptions","childN","serializedChildNode","isElement$1","isShadow","iframeEl","listener","win","readyState","fired","timer","blankUrl","onceIframeLoaded","iframeDoc","serializedIframeNode","link","styleSheetLoadTimeout","styleSheetLoaded","onceStylesheetLoaded","serializedLinkNode","on","fn","target","capture","passive","DEPARTED_MIRROR_ACCESS_WARNING","_mirror","map","throttle$1","func","wait","timeout","previous","args","now","Date","leading","remaining","context","getImplementation","clearTimeout$2","apply","trailing","setTimeout$1","hookSetter","d","isRevoked","original","getOwnPropertyDescriptor","patch","source","replacement","wrapped","defineProperties","__rrweb_original__","Proxy","Reflect","prop","receiver","nowTimestamp","getWindowScroll","left","scrollingElement","pageXOffset","documentElement","body","top","pageYOffset","getWindowHeight","innerHeight","clientHeight","getWindowWidth","innerWidth","clientWidth","closestElementOfNode","isBlocked","checkAncestors","blockedPredicate","isUnblocked","blockDistance","unblockDistance","isIgnored","isAncestorRemoved","legacy_isTouchEvent","event","changedTouches","isSerializedIframe","nodeName","isSerializedStylesheet","hasShadowRoot","getTime","StyleSheetMirror","styleIDMap","idStyleMap","newId","getStyle","generateId","getShadowHost","shadowHost","getRootNode","Node","DOCUMENT_FRAGMENT_NODE","shadowHostInDom","ownerDocument","rootShadowHost","getRootShadowHost","inDom","cachedImplementations","EventType","EventType2","IncrementalSource","IncrementalSource2","MouseInteractions","MouseInteractions2","PointerTypes","PointerTypes2","MediaInteractions","MediaInteractions2","getIFrameContentDocument","isNodeInLinkedList","DoubleLinkedList","tail","position","Error","current","index","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","shift","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","r2","_isParentRemoved","size","_isAncestorInSet","errorHandler","callbackWrapper","cb","mutationBuffers","getEventTarget","composedPath","initMutationObserver","rootEl","mutationBuffer","mutationObserverCtor","MutationObserver","__rrMutationObserver","angularZoneSymbol","Zone","__symbol__","observer","onMutation","observe","attributeOldValue","characterData","characterDataOldValue","childList","subtree","initMouseInteractionObserver","mouseInteractionCb","sampling","mouseInteraction","disableMap","handlers","currentPointerType","Number","isNaN","endsWith","eventKey","eventName","handler","pointerType","thisEventKey","Mouse","Touch","Pen","MouseDown","MouseUp","Click","clientX","clientY","getHandler","PointerEvent","TouchStart","TouchEnd","h","initScrollObserver","scrollCb","evt","defaultView","scrollLeftTop","scroll","INPUT_TAGS","lastInputValueMap","initInputObserver","inputCb","ignoreClass","ignoreSelector","userTriggeredOnInput","eventHandler","userTriggered","isTrusted","isChecked","cbWithDedup","querySelectorAll","el2","text2","v2","lastInputValue","input","currentWindow","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","sheets","result","adoptStyleSheets","initObservers","o2","_hooks","mutationObserver","recordDOM","mousemoveHandler","mousemoveCb","mousemove","threshold","callbackThreshold","mousemoveCallback","timeBaseline","positions","wrappedCb","totalOffset","timeOffset","updatePosition","DragEvent","Drag","MouseEvent","MouseMove","TouchMove","initMoveObserver","mouseInteractionHandler","scrollHandler","viewportResizeHandler","viewportResizeCb","lastH","lastW","initViewportResizeObserver","inputHandler","mediaInteractionHandler","mediaInteractionCb","volume","muted","playbackRate","Play","Pause","Seeked","VolumeChange","RateChange","initMediaInteractionObserver","styleSheetObserver","adoptedStyleSheetObserver","styleDeclarationObserver","fontObserver","styleSheetRuleCb","CSSStyleSheet","insertRule","thisArg","argumentsList","deleteRule","replaceSync","supportedNestedCSSRuleTypes","canMonkeyPatchNestedCSSRule","unmodifiedFunctions","entries","typeKey","initStyleSheetObserver","styleDeclarationCb","ignoreCSSAttributes","setProperty","CSSStyleDeclaration","priority","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","start","end","initSelectionObserver","customElementObserver","customElementCb","define","initCustomElementObserver","pluginHandlers","plugin","plugins","callback","b","disconnect","CrossOriginIframeMirror","generateIdFn","iframeIdToRemoteIdMap","iframeRemoteIdToIdMap","remoteId","idToRemoteMap","remoteToIdMap","idToRemoteIdMap","getIdToRemoteIdMap","remoteIdToIdMap","getRemoteIdToIdMap","getRemoteId","getRemoteIds","ids","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","isArray","child","ShadowDomManagerNoop","ShadowDomManager","shadowDoms","WeakSet","restoreHandlers","patchAttachShadow","iframeElement","iframeWindow","getIFrameContentWindow","manager","option","resetShadowRoots","chars","lookup","i$1","charCodeAt","CanvasManagerNoop","snapshot","StylesheetManager","trackedLinkElements","adoptedStyleSheetCb","linkEl","trackStylesheetInLinkElement","adoptedStyleSheetData","styleIds","CSSRule","_linkEl","ProcessedNodeManager","nodeMap","active","thisBuffer","buffers","onRequestAnimationFrame","destroy","_takeFullSnapshot","cleanFrame","debug","record","checkoutEveryNms","checkoutEveryNth","maskAllInputs","_maskInputOptions","_slimDOMOptions","maxCanvasSize","packFn","mousemoveWait","recordAfter","errorHandler2","getCanvasManager","inEmittingFrame","parent","passEmitsToParent","color","date","email","month","number","search","tel","time","week","select","radio","checkbox","lastFullSnapshotEvent","NodeList","DOMTokenList","TypeError","polyfill$1","incrementalSnapshotCount","eventProcessor","buf","postMessage","exceedCount","exceedTime","takeFullSnapshot2","wrappedMutationEmit","wrappedScrollEmit","wrappedCanvasMutationEmit","__RRWEB_EXCLUDE_IFRAME__","getMirror","nodeMirror","getCanvasManagerFn","_getCanvasManager","__RRWEB_EXCLUDE_SHADOW_DOM__","slimDOM","initialOffset","canvasMutationCb","CustomElement","n","t2","takeFullSnapshot","NotStarted","Running","Stopped","ReplayEventTypeIncrementalSnapshot","timestampToMs","timestampToS","addBreadcrumbEvent","replay","breadcrumb","category","triggerUserActivity","checkAndHandleExpiredSession","addUpdate","throttledAddEvent","tag","INTERACTIVE_SELECTOR","getClosestInteractive","closest","getClickTargetNode","getTargetNode","isEventWithTarget","onWindowOpen","originalWindowOpen","e","splice","IncrementalMutationSources","ClickDetector","slowClickConfig","_addBreadcrumbEvent","_lastMutation","_lastScroll","_clicks","_timeout","_threshold","_scrollTimeout","scrollTimeout","_replay","_ignoreSelector","addListeners","cleanupWindowOpen","nowInSeconds","_teardown","removeListeners","_checkClickTimeout","clearTimeout","handleClick","SLOW_CLICK_TAGS","ignoreElement","isClickBreadcrumb","newClick","clickBreadcrumb","clickCount","click","abs","_scheduleCheckClicks","registerMutation","registerScroll","registerClick","_handleMultiClick","_getClicks","_checkClicks","timedOutClicks","mutationAfter","undefined","scrollAfter","_generateBreadcrumbs","hadScroll","hadMutation","isSlowClick","timeAfterClickMs","endReason","route","getCurrentRoute","metric","updateClickDetectorForRecordingEvent","clickDetector","isIncrementalEvent","isIncrementalMouseInteraction","HTMLElement","createBreadcrumb","NodeType","ATTRIBUTES_TO_RECORD","getAttributesToRecord","normalizedKey","handleDomListener","handlerData","isEnabled","isClick","maxStringLength","getDomTarget","getBaseDomBreadcrumb","handleDom","altKey","metaKey","ctrlKey","shiftKey","isElement","handleKeyboardEvent","updateUserActivity","isContentEditable","isInputElement","hasModifierKey","isCharacterKey","baseBreadcrumb","getKeyboardBreadcrumb","ENTRY_TYPES","resource","entry","entryType","initiatorType","responseEnd","startTime","decodedBodySize","encodedBodySize","responseStatus","transferSize","getAbsoluteTime","statusCode","paint","duration","navigation","domComplete","domContentLoadedEventStart","domContentLoadedEventEnd","domInteractive","loadEventStart","loadEventEnd","redirectCount","webVitalHandler","getter","replayPerformanceEntries","createPerformanceEntry","performance","timeOrigin","getLargestContentfulPaint","lastEntry","getWebVital","isLayoutShift","sources","getCumulativeLayoutShift","layoutShifts","nodes","nodeIds","getFirstInputDelay","getInteractionToNextPaint","attributions","rating","DEBUG_BUILD","__SENTRY_DEBUG__","r","CONSOLE_LEVELS","PREFIX","_addBreadcrumb","level","logger","_capture","_trace","_logger","exception","infoTick","setConfig","opts","captureExceptions","traceInternals","info","setTimeout","makeReplayLogger","EventBufferSizeExceededError","super","EventBufferArray","events","_totalSize","hasCheckout","waitForCheckout","hasEvents","addEvent","eventSize","finish","Promise","resolve","eventsRet","clear","getEarliestTimestamp","sort","WorkerHandler","worker","_worker","ensureReady","_ensureReadyPromise","reject","success","once","terminate","method","arg","_getAndIncrementId","response","EventBufferCompressionWorker","_earliestTimestamp","_sendEventToWorker","_finishRequest","then","EventBufferProxy","_fallback","_compression","_used","_ensureWorkerIsLoadedPromise","_ensureWorkerIsLoaded","ensureWorkerIsLoaded","_switchToCompressionWorker","addEventPromises","all","createEventBuffer","useCompression","workerUrl","customWorkerUrl","Worker","__SENTRY_EXCLUDE_REPLAY_WORKER__","Blob","createObjectURL","_getWorkerUrl","_loadWorker","hasSessionStorage","sessionStorage","clearSession","removeItem","deleteSession","session","isSampled","sampleRate","random","makeSession","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","getOptions","beforeAddRecordingEvent","isExceeded","reason","handleException","stop","client","recordDroppedEvent","isPaused","timestampInMs","timeouts","sessionIdlePause","initialTimestamp","isErrorEvent","isTransactionEvent","isFeedbackEvent","handleAfterSendEvent","sendResponse","replayContext","contexts","trace","trace_id","traceIds","handleTransactionEvent","event_id","errorIds","tags","replayId","beforeErrorSampling","sendBufferedReplayOrFlush","handleErrorEvent","handleBeforeSendEvent","exceptionValue","values","handleHydrationError","handleBreadcrumbs","isBreadcrumbWithCategory","arguments","isTruncated","normalizedArgs","normalizedArg","_meta","warnings","normalizeConsoleBreadcrumb","normalizeBreadcrumb","beforeAddBreadcrumb","resetReplayIdOnDynamicSamplingContext","dsc","getPropagationContext","replay_id","activeSpan","handleGlobalEventListener","hint","isReplayEvent","breadcrumbs","flush","feedback","getSessionId","feedbackId","addFeedbackBreadcrumb","originalException","__rrweb__","isRrwebError","_experiments","log","isErrorEventSampled","errorSampleRate","shouldSampleForBufferEvent","createPerformanceSpans","op","description","startTimestamp","endTimestamp","handleHistorySpanListener","to","handleHistory","urls","addNetworkBreadcrumb","shouldFilterRequest","getBodySize","textEncoder","TextEncoder","encode","URLSearchParams","FormData","formDataStr","ArrayBuffer","byteLength","parseContentLengthHeader","header","parseInt","mergeWarning","warning","headers","newMeta","existingWarnings","makeNetworkReplayBreadcrumb","request","buildSkippedNetworkRequestOrResponse","bodySize","buildNetworkRequestOrResponse","normalizedBody","exceedsSizeLimit","isProbablyJson","first","last","_strIsProbablyJson","truncatedBody","normalizeNetworkBody","getAllowedHeaders","allowedHeaders","reduce","filteredHeaders","urlMatches","fullUrl","baseURI","fixedUrl","getFullUrl","captureFetchBreadcrumbToReplay","status_code","request_body_size","requestBodySize","response_body_size","responseBodySize","captureDetails","networkDetailAllowUrls","networkDetailDenyUrls","networkCaptureBodies","networkRequestHeaders","fetchArgs","getHeadersFromOptions","getRequestHeaders","requestBody","bodyStr","_getRequestInfo","networkResponseHeaders","getAllHeaders","bodyText","res","clone","_tryCloneResponse","_getResponseText","txt","finally","_tryGetResponseText","_parseFetchResponseBody","getResponseData","_getResponseInfo","_prepareFetchData","allHeaders","Headers","captureXhrBreadcrumbToReplay","xhr","xhrInfo","request_headers","getAllResponseHeaders","acc","line","getResponseHeaders","requestWarning","responseBody","responseWarning","errors","responseText","responseType","outerHTML","_parseXhrResponse","_getXhrResponseBody","_prepareXhrData","enrichXhrBreadcrumb","reqSize","resSize","getResponseHeader","_getBodySize","handleNetworkBreadcrumbs","_isXhrBreadcrumb","_isXhrHint","_isFetchBreadcrumb","_isFetchHint","enrichFetchBreadcrumb","beforeAddNetworkBreadcrumb","createMemoryEntry","memoryEntry","jsHeapSizeLimit","totalJSHeapSize","usedJSHeapSize","memory","NAVIGATOR","navigator","getHandleRecordingEmit","hadFirstEvent","_isCheckout","setInitialState","shouldRecordCanvas","isRecordingCanvas","useCompressionOption","blockAllMedia","networkDetailHasUrls","networkRequestHasHeaders","networkResponseHasHeaders","createOptionsEvent","addSettingsEvent","earliestEvent","sendReplayRequest","recordingData","segment_id","eventContext","preparedRecordingData","payloadWithSequence","replayHeaders","sequence","prepareRecordingData","scope","transport","getTransport","dsn","getDsn","baseEvent","replay_start_timestamp","error_ids","trace_ids","replay_type","replayEvent","eventHint","integrations","preparedEvent","platform","metadata","getSdkMetadata","version","sdk","prepareReplayEvent","sdkProcessingMetadata","envelope","tunnel","createReplayEnvelope","send","cause","TransportStatusCodeError","rateLimits","RateLimitError","sendReplay","replayData","retryConfig","interval","onError","_retryCount","THROTTLED","throttle","maxCount","durationSeconds","counter","isThrottled","floor","_cleanup","a","wasThrottled","ReplayContainer","recordingOptions","performanceEntries","_lastActivity","_isEnabled","_isPaused","_requiresManualStart","_hasInitializedCoreListeners","_context","initialUrl","_recordingOptions","_options","_debouncedFlush","callbackReturnValue","timerId","maxTimerId","maxWait","max","invokeFunc","cancelTimers","debounced","cancel","debounce","_flush","flushMinDelay","flushMaxDelay","_throttledAddEvent","slowClickTimeout","slowClickIgnoreSelectors","experiments","_handleVisibilityChange","visibilityState","_doChangeToForegroundTasks","_doChangeToBackgroundTasks","_handleWindowBlur","_handleWindowFocus","_handleKeyboardEvent","_canvas","initializeSampling","requiresManualStart","_initializeSessionForSampling","_initializeRecording","_updateUserActivity","startBuffering","startRecording","canvasOptions","_stopRecording","continuousCheckout","userAgent","maxTouchPoints","_onMutationHandler","stopRecording","forceFlush","_removeListeners","force","pause","resume","_checkSession","continueRecording","flushImmediate","activityTime","hasStoppedRecording","_updateSessionActivity","_maybeSaveSession","cbResult","conditionalFlush","cancelFlush","urlPath","hash","_clearContext","lastActiveSpan","lastRootSpan","_addListeners","currentSession","_refreshSession","autoFlushOnFeedback","span","feedbackEvent","includeReplay","addGlobalListeners","_performanceCleanupCallback","addPerformanceEntry","onEntries","clearCallbacks","clearCallback","setupPerformanceObserver","_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","mask","maskAttributes","unmask","block","unblock","ignore","maskFn","privacyOptions","getPrivacyOptions","password","maskAttribute","_initialOptions","_getMergedNetworkHeaders","_isInitialized","afterAllSetup","_setup","_initialize","getReplayId","getRecordingMode","_maybeLoadFromReplayCanvasIntegration","finalOptions","initialOptions","opt","replaysSessionSampleRate","replaysOnErrorSampleRate","loadReplayOptionsFromClient","canvasIntegration","getIntegrationByName","getReplay"],"sourceRoot":""}