{"version":3,"file":"d904c7bf-af0a42af23d61fc85702.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, dropUndefinedKeys, stringMatchesSomePattern, addEventProcessor, createEnvelope, createEventEnvelopeHeaders, getSdkMetadataForEnvelopeHeader, prepareEvent, getIsolationScope, resolvedSyncPromise, updateRateLimits, isRateLimited, setContext, getRootSpan, spanToJSON, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, isBrowser, parseSampleRate, consoleSandbox } from '@sentry/core';\nimport { setTimeout as setTimeout$3, addPerformanceInstrumentationHandler, addLcpInstrumentationHandler, addClsInstrumentationHandler, addFidInstrumentationHandler, addInpInstrumentationHandler, 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 NodeType$3;\n(function (NodeType) {\n    NodeType[NodeType[\"Document\"] = 0] = \"Document\";\n    NodeType[NodeType[\"DocumentType\"] = 1] = \"DocumentType\";\n    NodeType[NodeType[\"Element\"] = 2] = \"Element\";\n    NodeType[NodeType[\"Text\"] = 3] = \"Text\";\n    NodeType[NodeType[\"CDATA\"] = 4] = \"CDATA\";\n    NodeType[NodeType[\"Comment\"] = 5] = \"Comment\";\n})(NodeType$3 || (NodeType$3 = {}));\n\nfunction isElement$1(n) {\n    return n.nodeType === n.ELEMENT_NODE;\n}\nfunction isShadowRoot(n) {\n    const host = n?.host;\n    return Boolean(host?.shadowRoot === n);\n}\nfunction isNativeShadowDom(shadowRoot) {\n    return Object.prototype.toString.call(shadowRoot) === '[object ShadowRoot]';\n}\nfunction fixBrowserCompatibilityIssuesInCSS(cssText) {\n    if (cssText.includes(' background-clip: text;') &&\n        !cssText.includes(' -webkit-background-clip: text;')) {\n        cssText = cssText.replace(/\\sbackground-clip:\\s*text;/g, ' -webkit-background-clip: text; background-clip: text;');\n    }\n    return cssText;\n}\nfunction escapeImportStatement(rule) {\n    const { cssText } = rule;\n    if (cssText.split('\"').length < 3)\n        return cssText;\n    const statement = ['@import', `url(${JSON.stringify(rule.href)})`];\n    if (rule.layerName === '') {\n        statement.push(`layer`);\n    }\n    else if (rule.layerName) {\n        statement.push(`layer(${rule.layerName})`);\n    }\n    if (rule.supportsText) {\n        statement.push(`supports(${rule.supportsText})`);\n    }\n    if (rule.media.length) {\n        statement.push(rule.media.mediaText);\n    }\n    return statement.join(' ') + ';';\n}\nfunction stringifyStylesheet(s) {\n    try {\n        const rules = s.rules || s.cssRules;\n        return rules\n            ? fixBrowserCompatibilityIssuesInCSS(Array.from(rules, stringifyRule).join(''))\n            : null;\n    }\n    catch (error) {\n        return null;\n    }\n}\nfunction fixAllCssProperty(rule) {\n    let styles = '';\n    for (let i = 0; i < rule.style.length; i++) {\n        const styleDeclaration = rule.style;\n        const attribute = styleDeclaration[i];\n        const isImportant = styleDeclaration.getPropertyPriority(attribute);\n        styles += `${attribute}:${styleDeclaration.getPropertyValue(attribute)}${isImportant ? ` !important` : ''};`;\n    }\n    return `${rule.selectorText} { ${styles} }`;\n}\nfunction stringifyRule(rule) {\n    let importStringified;\n    if (isCSSImportRule(rule)) {\n        try {\n            importStringified =\n                stringifyStylesheet(rule.styleSheet) ||\n                    escapeImportStatement(rule);\n        }\n        catch (error) {\n        }\n    }\n    else if (isCSSStyleRule(rule)) {\n        let cssText = rule.cssText;\n        const needsSafariColonFix = rule.selectorText.includes(':');\n        const needsAllFix = typeof rule.style['all'] === 'string' && rule.style['all'];\n        if (needsAllFix) {\n            cssText = fixAllCssProperty(rule);\n        }\n        if (needsSafariColonFix) {\n            cssText = fixSafariColons(cssText);\n        }\n        if (needsSafariColonFix || needsAllFix) {\n            return cssText;\n        }\n    }\n    return importStringified || rule.cssText;\n}\nfunction fixSafariColons(cssStringified) {\n    const regex = /(\\[(?:[\\w-]+)[^\\\\])(:(?:[\\w-]+)\\])/gm;\n    return cssStringified.replace(regex, '$1\\\\$2');\n}\nfunction isCSSImportRule(rule) {\n    return 'styleSheet' in rule;\n}\nfunction isCSSStyleRule(rule) {\n    return 'selectorText' in rule;\n}\nclass Mirror {\n    constructor() {\n        this.idNodeMap = new Map();\n        this.nodeMetaMap = new WeakMap();\n    }\n    getId(n) {\n        if (!n)\n            return -1;\n        const id = this.getMeta(n)?.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(n) {\n        return this.nodeMetaMap.get(n) || null;\n    }\n    removeNodeFromMap(n) {\n        const id = this.getId(n);\n        this.idNodeMap.delete(id);\n        if (n.childNodes) {\n            n.childNodes.forEach((childNode) => this.removeNodeFromMap(childNode));\n        }\n    }\n    has(id) {\n        return this.idNodeMap.has(id);\n    }\n    hasNode(node) {\n        return this.nodeMetaMap.has(node);\n    }\n    add(n, meta) {\n        const id = meta.id;\n        this.idNodeMap.set(id, n);\n        this.nodeMetaMap.set(n, meta);\n    }\n    replace(id, n) {\n        const oldNode = this.getNode(id);\n        if (oldNode) {\n            const meta = this.nodeMetaMap.get(oldNode);\n            if (meta)\n                this.nodeMetaMap.set(n, meta);\n        }\n        this.idNodeMap.set(id, n);\n    }\n    reset() {\n        this.idNodeMap = new Map();\n        this.nodeMetaMap = new WeakMap();\n    }\n}\nfunction createMirror() {\n    return new Mirror();\n}\nfunction shouldMaskInput({ maskInputOptions, tagName, type, }) {\n    if (tagName === 'OPTION') {\n        tagName = 'SELECT';\n    }\n    return Boolean(maskInputOptions[tagName.toLowerCase()] ||\n        (type && maskInputOptions[type]) ||\n        type === 'password' ||\n        (tagName === 'INPUT' && !type && maskInputOptions['text']));\n}\nfunction maskInputValue({ isMasked, element, value, maskInputFn, }) {\n    let text = value || '';\n    if (!isMasked) {\n        return text;\n    }\n    if (maskInputFn) {\n        text = maskInputFn(text, element);\n    }\n    return '*'.repeat(text.length);\n}\nfunction toLowerCase(str) {\n    return str.toLowerCase();\n}\nfunction toUpperCase(str) {\n    return str.toUpperCase();\n}\nconst ORIGINAL_ATTRIBUTE_NAME = '__rrweb_original__';\nfunction is2DCanvasBlank(canvas) {\n    const ctx = canvas.getContext('2d');\n    if (!ctx)\n        return true;\n    const chunkSize = 50;\n    for (let x = 0; x < canvas.width; x += chunkSize) {\n        for (let y = 0; y < canvas.height; y += chunkSize) {\n            const getImageData = ctx.getImageData;\n            const originalGetImageData = ORIGINAL_ATTRIBUTE_NAME in getImageData\n                ? getImageData[ORIGINAL_ATTRIBUTE_NAME]\n                : getImageData;\n            const pixelBuffer = new Uint32Array(originalGetImageData.call(ctx, x, y, Math.min(chunkSize, canvas.width - x), Math.min(chunkSize, canvas.height - y)).data.buffer);\n            if (pixelBuffer.some((pixel) => pixel !== 0))\n                return false;\n        }\n    }\n    return true;\n}\nfunction getInputType(element) {\n    const type = element.type;\n    return element.hasAttribute('data-rr-is-password')\n        ? 'password'\n        : type\n            ?\n                toLowerCase(type)\n            : null;\n}\nfunction getInputValue(el, tagName, type) {\n    if (tagName === 'INPUT' && (type === 'radio' || type === 'checkbox')) {\n        return el.getAttribute('value') || '';\n    }\n    return el.value;\n}\nfunction extractFileExtension(path, baseURL) {\n    let url;\n    try {\n        url = new URL(path, baseURL ?? window.location.href);\n    }\n    catch (err) {\n        return null;\n    }\n    const regex = /\\.([0-9a-z]+)(?:$)/i;\n    const match = url.pathname.match(regex);\n    return 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 document = window.document;\n    let impl = window[name];\n    if (document && typeof document.createElement === 'function') {\n        try {\n            const sandbox = document.createElement('iframe');\n            sandbox.hidden = true;\n            document.head.appendChild(sandbox);\n            const contentWindow = sandbox.contentWindow;\n            if (contentWindow && contentWindow[name]) {\n                impl =\n                    contentWindow[name];\n            }\n            document.head.removeChild(sandbox);\n        }\n        catch (e) {\n        }\n    }\n    return (cachedImplementations$1[name] = impl.bind(window));\n}\nfunction setTimeout$2(...rest) {\n    return getImplementation$1('setTimeout')(...rest);\n}\nfunction clearTimeout$2(...rest) {\n    return getImplementation$1('clearTimeout')(...rest);\n}\nfunction getIframeContentDocument(iframe) {\n    try {\n        return iframe.contentDocument;\n    }\n    catch (e) {\n    }\n}\n\nlet _id = 1;\nconst tagNameRegex = new RegExp('[^a-z0-9-_:]');\nconst IGNORED_NODE = -2;\nfunction genId() {\n    return _id++;\n}\nfunction getValidTagName(element) {\n    if (element instanceof HTMLFormElement) {\n        return 'form';\n    }\n    const processedTagName = toLowerCase(element.tagName);\n    if (tagNameRegex.test(processedTagName)) {\n        return 'div';\n    }\n    return processedTagName;\n}\nfunction extractOrigin(url) {\n    let origin = '';\n    if (url.indexOf('//') > -1) {\n        origin = url.split('/').slice(0, 3).join('/');\n    }\n    else {\n        origin = url.split('/')[0];\n    }\n    origin = origin.split('?')[0];\n    return origin;\n}\nlet canvasService;\nlet canvasCtx;\nconst URL_IN_CSS_REF = /url\\((?:(')([^']*)'|(\")(.*?)\"|([^)]*))\\)/gm;\nconst URL_PROTOCOL_MATCH = /^(?:[a-z+]+:)?\\/\\//i;\nconst URL_WWW_MATCH = /^www\\..*/i;\nconst DATA_URI = /^(data:)([^,]*),(.*)/i;\nfunction absoluteToStylesheet(cssText, href) {\n    return (cssText || '').replace(URL_IN_CSS_REF, (origin, quote1, path1, quote2, path2, path3) => {\n        const filePath = path1 || path2 || path3;\n        const maybeQuote = quote1 || quote2 || '';\n        if (!filePath) {\n            return origin;\n        }\n        if (URL_PROTOCOL_MATCH.test(filePath) || URL_WWW_MATCH.test(filePath)) {\n            return `url(${maybeQuote}${filePath}${maybeQuote})`;\n        }\n        if (DATA_URI.test(filePath)) {\n            return `url(${maybeQuote}${filePath}${maybeQuote})`;\n        }\n        if (filePath[0] === '/') {\n            return `url(${maybeQuote}${extractOrigin(href) + filePath}${maybeQuote})`;\n        }\n        const stack = href.split('/');\n        const parts = filePath.split('/');\n        stack.pop();\n        for (const part of parts) {\n            if (part === '.') {\n                continue;\n            }\n            else if (part === '..') {\n                stack.pop();\n            }\n            else {\n                stack.push(part);\n            }\n        }\n        return `url(${maybeQuote}${stack.join('/')}${maybeQuote})`;\n    });\n}\nconst SRCSET_NOT_SPACES = /^[^ \\t\\n\\r\\u000c]+/;\nconst SRCSET_COMMAS_OR_SPACES = /^[, \\t\\n\\r\\u000c]+/;\nfunction getAbsoluteSrcsetString(doc, attributeValue) {\n    if (attributeValue.trim() === '') {\n        return attributeValue;\n    }\n    let pos = 0;\n    function collectCharacters(regEx) {\n        let chars;\n        const match = regEx.exec(attributeValue.substring(pos));\n        if (match) {\n            chars = match[0];\n            pos += chars.length;\n            return chars;\n        }\n        return '';\n    }\n    const output = [];\n    while (true) {\n        collectCharacters(SRCSET_COMMAS_OR_SPACES);\n        if (pos >= attributeValue.length) {\n            break;\n        }\n        let url = collectCharacters(SRCSET_NOT_SPACES);\n        if (url.slice(-1) === ',') {\n            url = absoluteToDoc(doc, url.substring(0, url.length - 1));\n            output.push(url);\n        }\n        else {\n            let descriptorsStr = '';\n            url = absoluteToDoc(doc, url);\n            let inParens = false;\n            while (true) {\n                const c = attributeValue.charAt(pos);\n                if (c === '') {\n                    output.push((url + descriptorsStr).trim());\n                    break;\n                }\n                else if (!inParens) {\n                    if (c === ',') {\n                        pos += 1;\n                        output.push((url + descriptorsStr).trim());\n                        break;\n                    }\n                    else if (c === '(') {\n                        inParens = true;\n                    }\n                }\n                else {\n                    if (c === ')') {\n                        inParens = false;\n                    }\n                }\n                descriptorsStr += c;\n                pos += 1;\n            }\n        }\n    }\n    return output.join(', ');\n}\nconst cachedDocument = new WeakMap();\nfunction absoluteToDoc(doc, attributeValue) {\n    if (!attributeValue || attributeValue.trim() === '') {\n        return attributeValue;\n    }\n    return getHref(doc, attributeValue);\n}\nfunction isSVGElement(el) {\n    return Boolean(el.tagName === 'svg' || el.ownerSVGElement);\n}\nfunction getHref(doc, customHref) {\n    let a = cachedDocument.get(doc);\n    if (!a) {\n        a = doc.createElement('a');\n        cachedDocument.set(doc, a);\n    }\n    if (!customHref) {\n        customHref = '';\n    }\n    else if (customHref.startsWith('blob:') || customHref.startsWith('data:')) {\n        return customHref;\n    }\n    a.setAttribute('href', customHref);\n    return a.href;\n}\nfunction transformAttribute(doc, tagName, name, value, element, maskAttributeFn) {\n    if (!value) {\n        return value;\n    }\n    if (name === 'src' ||\n        (name === 'href' && !(tagName === 'use' && value[0] === '#'))) {\n        return absoluteToDoc(doc, value);\n    }\n    else if (name === 'xlink:href' && value[0] !== '#') {\n        return absoluteToDoc(doc, value);\n    }\n    else if (name === 'background' &&\n        (tagName === 'table' || tagName === 'td' || tagName === 'th')) {\n        return absoluteToDoc(doc, value);\n    }\n    else if (name === 'srcset') {\n        return getAbsoluteSrcsetString(doc, value);\n    }\n    else if (name === 'style') {\n        return absoluteToStylesheet(value, getHref(doc));\n    }\n    else if (tagName === 'object' && name === 'data') {\n        return absoluteToDoc(doc, value);\n    }\n    if (typeof maskAttributeFn === 'function') {\n        return maskAttributeFn(name, value, element);\n    }\n    return value;\n}\nfunction ignoreAttribute(tagName, name, _value) {\n    return (tagName === 'video' || tagName === 'audio') && name === 'autoplay';\n}\nfunction _isBlockedElement(element, blockClass, blockSelector, unblockSelector) {\n    try {\n        if (unblockSelector && element.matches(unblockSelector)) {\n            return false;\n        }\n        if (typeof blockClass === 'string') {\n            if (element.classList.contains(blockClass)) {\n                return true;\n            }\n        }\n        else {\n            for (let eIndex = element.classList.length; eIndex--;) {\n                const className = element.classList[eIndex];\n                if (blockClass.test(className)) {\n                    return true;\n                }\n            }\n        }\n        if (blockSelector) {\n            return element.matches(blockSelector);\n        }\n    }\n    catch (e) {\n    }\n    return false;\n}\nfunction elementClassMatchesRegex(el, regex) {\n    for (let eIndex = el.classList.length; eIndex--;) {\n        const className = el.classList[eIndex];\n        if (regex.test(className)) {\n            return true;\n        }\n    }\n    return false;\n}\nfunction distanceToMatch(node, matchPredicate, limit = Infinity, distance = 0) {\n    if (!node)\n        return -1;\n    if (node.nodeType !== node.ELEMENT_NODE)\n        return -1;\n    if (distance > limit)\n        return -1;\n    if (matchPredicate(node))\n        return distance;\n    return distanceToMatch(node.parentNode, matchPredicate, limit, distance + 1);\n}\nfunction createMatchPredicate(className, selector) {\n    return (node) => {\n        const el = node;\n        if (el === null)\n            return false;\n        try {\n            if (className) {\n                if (typeof className === 'string') {\n                    if (el.matches(`.${className}`))\n                        return true;\n                }\n                else if (elementClassMatchesRegex(el, className)) {\n                    return true;\n                }\n            }\n            if (selector && el.matches(selector))\n                return true;\n            return false;\n        }\n        catch {\n            return false;\n        }\n    };\n}\nfunction needMaskingText(node, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, maskAllText) {\n    try {\n        const el = node.nodeType === node.ELEMENT_NODE\n            ? node\n            : node.parentElement;\n        if (el === null)\n            return false;\n        if (el.tagName === 'INPUT') {\n            const autocomplete = el.getAttribute('autocomplete');\n            const disallowedAutocompleteValues = [\n                'current-password',\n                'new-password',\n                'cc-number',\n                'cc-exp',\n                'cc-exp-month',\n                'cc-exp-year',\n                'cc-csc',\n            ];\n            if (disallowedAutocompleteValues.includes(autocomplete)) {\n                return true;\n            }\n        }\n        let maskDistance = -1;\n        let unmaskDistance = -1;\n        if (maskAllText) {\n            unmaskDistance = distanceToMatch(el, createMatchPredicate(unmaskTextClass, unmaskTextSelector));\n            if (unmaskDistance < 0) {\n                return true;\n            }\n            maskDistance = distanceToMatch(el, createMatchPredicate(maskTextClass, maskTextSelector), unmaskDistance >= 0 ? unmaskDistance : Infinity);\n        }\n        else {\n            maskDistance = distanceToMatch(el, createMatchPredicate(maskTextClass, maskTextSelector));\n            if (maskDistance < 0) {\n                return false;\n            }\n            unmaskDistance = distanceToMatch(el, createMatchPredicate(unmaskTextClass, unmaskTextSelector), maskDistance >= 0 ? maskDistance : Infinity);\n        }\n        return maskDistance >= 0\n            ? unmaskDistance >= 0\n                ? maskDistance <= unmaskDistance\n                : true\n            : unmaskDistance >= 0\n                ? false\n                : !!maskAllText;\n    }\n    catch (e) {\n    }\n    return !!maskAllText;\n}\nfunction onceIframeLoaded(iframeEl, listener, iframeLoadTimeout) {\n    const win = iframeEl.contentWindow;\n    if (!win) {\n        return;\n    }\n    let fired = false;\n    let readyState;\n    try {\n        readyState = win.document.readyState;\n    }\n    catch (error) {\n        return;\n    }\n    if (readyState !== 'complete') {\n        const timer = setTimeout$2(() => {\n            if (!fired) {\n                listener();\n                fired = true;\n            }\n        }, iframeLoadTimeout);\n        iframeEl.addEventListener('load', () => {\n            clearTimeout$2(timer);\n            fired = true;\n            listener();\n        });\n        return;\n    }\n    const blankUrl = 'about:blank';\n    if (win.location.href !== blankUrl ||\n        iframeEl.src === blankUrl ||\n        iframeEl.src === '') {\n        setTimeout$2(listener, 0);\n        return iframeEl.addEventListener('load', listener);\n    }\n    iframeEl.addEventListener('load', listener);\n}\nfunction onceStylesheetLoaded(link, listener, styleSheetLoadTimeout) {\n    let fired = false;\n    let styleSheetLoaded;\n    try {\n        styleSheetLoaded = link.sheet;\n    }\n    catch (error) {\n        return;\n    }\n    if (styleSheetLoaded)\n        return;\n    const timer = setTimeout$2(() => {\n        if (!fired) {\n            listener();\n            fired = true;\n        }\n    }, styleSheetLoadTimeout);\n    link.addEventListener('load', () => {\n        clearTimeout$2(timer);\n        fired = true;\n        listener();\n    });\n}\nfunction serializeNode(n, options) {\n    const { doc, mirror, blockClass, blockSelector, unblockSelector, maskAllText, maskAttributeFn, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, inlineStylesheet, maskInputOptions = {}, maskTextFn, maskInputFn, dataURLOptions = {}, inlineImages, recordCanvas, keepIframeSrcFn, newlyAddedElement = false, } = options;\n    const rootId = getRootId(doc, mirror);\n    switch (n.nodeType) {\n        case n.DOCUMENT_NODE:\n            if (n.compatMode !== 'CSS1Compat') {\n                return {\n                    type: NodeType$3.Document,\n                    childNodes: [],\n                    compatMode: n.compatMode,\n                };\n            }\n            else {\n                return {\n                    type: NodeType$3.Document,\n                    childNodes: [],\n                };\n            }\n        case n.DOCUMENT_TYPE_NODE:\n            return {\n                type: NodeType$3.DocumentType,\n                name: n.name,\n                publicId: n.publicId,\n                systemId: n.systemId,\n                rootId,\n            };\n        case n.ELEMENT_NODE:\n            return serializeElementNode(n, {\n                doc,\n                blockClass,\n                blockSelector,\n                unblockSelector,\n                inlineStylesheet,\n                maskAttributeFn,\n                maskInputOptions,\n                maskInputFn,\n                dataURLOptions,\n                inlineImages,\n                recordCanvas,\n                keepIframeSrcFn,\n                newlyAddedElement,\n                rootId,\n                maskAllText,\n                maskTextClass,\n                unmaskTextClass,\n                maskTextSelector,\n                unmaskTextSelector,\n            });\n        case n.TEXT_NODE:\n            return serializeTextNode(n, {\n                doc,\n                maskAllText,\n                maskTextClass,\n                unmaskTextClass,\n                maskTextSelector,\n                unmaskTextSelector,\n                maskTextFn,\n                maskInputOptions,\n                maskInputFn,\n                rootId,\n            });\n        case n.CDATA_SECTION_NODE:\n            return {\n                type: NodeType$3.CDATA,\n                textContent: '',\n                rootId,\n            };\n        case n.COMMENT_NODE:\n            return {\n                type: NodeType$3.Comment,\n                textContent: n.textContent || '',\n                rootId,\n            };\n        default:\n            return false;\n    }\n}\nfunction getRootId(doc, mirror) {\n    if (!mirror.hasNode(doc))\n        return undefined;\n    const docId = mirror.getId(doc);\n    return docId === 1 ? undefined : docId;\n}\nfunction serializeTextNode(n, options) {\n    const { maskAllText, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, maskTextFn, maskInputOptions, maskInputFn, rootId, } = options;\n    const parentTagName = n.parentNode && n.parentNode.tagName;\n    let textContent = n.textContent;\n    const isStyle = parentTagName === 'STYLE' ? true : undefined;\n    const isScript = parentTagName === 'SCRIPT' ? true : undefined;\n    const isTextarea = parentTagName === 'TEXTAREA' ? true : undefined;\n    if (isStyle && textContent) {\n        try {\n            if (n.nextSibling || n.previousSibling) {\n            }\n            else if (n.parentNode.sheet?.cssRules) {\n                textContent = stringifyStylesheet(n.parentNode.sheet);\n            }\n        }\n        catch (err) {\n            console.warn(`Cannot get CSS styles from text's parentNode. Error: ${err}`, n);\n        }\n        textContent = absoluteToStylesheet(textContent, getHref(options.doc));\n    }\n    if (isScript) {\n        textContent = 'SCRIPT_PLACEHOLDER';\n    }\n    const forceMask = needMaskingText(n, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, maskAllText);\n    if (!isStyle && !isScript && !isTextarea && textContent && forceMask) {\n        textContent = maskTextFn\n            ? maskTextFn(textContent, n.parentElement)\n            : textContent.replace(/[\\S]/g, '*');\n    }\n    if (isTextarea && textContent && (maskInputOptions.textarea || forceMask)) {\n        textContent = maskInputFn\n            ? maskInputFn(textContent, n.parentNode)\n            : textContent.replace(/[\\S]/g, '*');\n    }\n    if (parentTagName === 'OPTION' && textContent) {\n        const isInputMasked = shouldMaskInput({\n            type: null,\n            tagName: parentTagName,\n            maskInputOptions,\n        });\n        textContent = maskInputValue({\n            isMasked: needMaskingText(n, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, isInputMasked),\n            element: n,\n            value: textContent,\n            maskInputFn,\n        });\n    }\n    return {\n        type: NodeType$3.Text,\n        textContent: textContent || '',\n        isStyle,\n        rootId,\n    };\n}\nfunction serializeElementNode(n, options) {\n    const { doc, blockClass, blockSelector, unblockSelector, inlineStylesheet, maskInputOptions = {}, maskAttributeFn, maskInputFn, dataURLOptions = {}, inlineImages, recordCanvas, keepIframeSrcFn, newlyAddedElement = false, rootId, maskAllText, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, } = options;\n    const needBlock = _isBlockedElement(n, blockClass, blockSelector, unblockSelector);\n    const tagName = getValidTagName(n);\n    let attributes = {};\n    const len = n.attributes.length;\n    for (let i = 0; i < len; i++) {\n        const attr = n.attributes[i];\n        if (attr.name && !ignoreAttribute(tagName, attr.name, attr.value)) {\n            attributes[attr.name] = transformAttribute(doc, tagName, toLowerCase(attr.name), attr.value, n, maskAttributeFn);\n        }\n    }\n    if (tagName === 'link' && inlineStylesheet) {\n        const stylesheet = Array.from(doc.styleSheets).find((s) => {\n            return s.href === n.href;\n        });\n        let cssText = null;\n        if (stylesheet) {\n            cssText = stringifyStylesheet(stylesheet);\n        }\n        if (cssText) {\n            attributes.rel = null;\n            attributes.href = null;\n            attributes.crossorigin = null;\n            attributes._cssText = absoluteToStylesheet(cssText, stylesheet.href);\n        }\n    }\n    if (tagName === 'style' &&\n        n.sheet &&\n        !(n.innerText || n.textContent || '').trim().length) {\n        const cssText = stringifyStylesheet(n.sheet);\n        if (cssText) {\n            attributes._cssText = absoluteToStylesheet(cssText, getHref(doc));\n        }\n    }\n    if (tagName === 'input' ||\n        tagName === 'textarea' ||\n        tagName === 'select' ||\n        tagName === 'option') {\n        const el = n;\n        const type = getInputType(el);\n        const value = getInputValue(el, toUpperCase(tagName), type);\n        const checked = el.checked;\n        if (type !== 'submit' && type !== 'button' && value) {\n            const forceMask = needMaskingText(el, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, shouldMaskInput({\n                type,\n                tagName: toUpperCase(tagName),\n                maskInputOptions,\n            }));\n            attributes.value = maskInputValue({\n                isMasked: forceMask,\n                element: el,\n                value,\n                maskInputFn,\n            });\n        }\n        if (checked) {\n            attributes.checked = checked;\n        }\n    }\n    if (tagName === 'option') {\n        if (n.selected && !maskInputOptions['select']) {\n            attributes.selected = true;\n        }\n        else {\n            delete attributes.selected;\n        }\n    }\n    if (tagName === 'canvas' && recordCanvas) {\n        if (n.__context === '2d') {\n            if (!is2DCanvasBlank(n)) {\n                attributes.rr_dataURL = n.toDataURL(dataURLOptions.type, dataURLOptions.quality);\n            }\n        }\n        else if (!('__context' in n)) {\n            const canvasDataURL = n.toDataURL(dataURLOptions.type, dataURLOptions.quality);\n            const blankCanvas = doc.createElement('canvas');\n            blankCanvas.width = n.width;\n            blankCanvas.height = n.height;\n            const blankCanvasDataURL = blankCanvas.toDataURL(dataURLOptions.type, dataURLOptions.quality);\n            if (canvasDataURL !== blankCanvasDataURL) {\n                attributes.rr_dataURL = canvasDataURL;\n            }\n        }\n    }\n    if (tagName === 'img' && inlineImages) {\n        if (!canvasService) {\n            canvasService = doc.createElement('canvas');\n            canvasCtx = canvasService.getContext('2d');\n        }\n        const image = n;\n        const imageSrc = image.currentSrc || image.getAttribute('src') || '<unknown-src>';\n        const priorCrossOrigin = image.crossOrigin;\n        const recordInlineImage = () => {\n            image.removeEventListener('load', recordInlineImage);\n            try {\n                canvasService.width = image.naturalWidth;\n                canvasService.height = image.naturalHeight;\n                canvasCtx.drawImage(image, 0, 0);\n                attributes.rr_dataURL = canvasService.toDataURL(dataURLOptions.type, dataURLOptions.quality);\n            }\n            catch (err) {\n                if (image.crossOrigin !== 'anonymous') {\n                    image.crossOrigin = 'anonymous';\n                    if (image.complete && image.naturalWidth !== 0)\n                        recordInlineImage();\n                    else\n                        image.addEventListener('load', recordInlineImage);\n                    return;\n                }\n                else {\n                    console.warn(`Cannot inline img src=${imageSrc}! Error: ${err}`);\n                }\n            }\n            if (image.crossOrigin === 'anonymous') {\n                priorCrossOrigin\n                    ? (attributes.crossOrigin = priorCrossOrigin)\n                    : image.removeAttribute('crossorigin');\n            }\n        };\n        if (image.complete && image.naturalWidth !== 0)\n            recordInlineImage();\n        else\n            image.addEventListener('load', recordInlineImage);\n    }\n    if (tagName === 'audio' || tagName === 'video') {\n        attributes.rr_mediaState = n.paused\n            ? 'paused'\n            : 'played';\n        attributes.rr_mediaCurrentTime = n.currentTime;\n    }\n    if (!newlyAddedElement) {\n        if (n.scrollLeft) {\n            attributes.rr_scrollLeft = n.scrollLeft;\n        }\n        if (n.scrollTop) {\n            attributes.rr_scrollTop = n.scrollTop;\n        }\n    }\n    if (needBlock) {\n        const { width, height } = n.getBoundingClientRect();\n        attributes = {\n            class: attributes.class,\n            rr_width: `${width}px`,\n            rr_height: `${height}px`,\n        };\n    }\n    if (tagName === 'iframe' && !keepIframeSrcFn(attributes.src)) {\n        if (!needBlock && !getIframeContentDocument(n)) {\n            attributes.rr_src = attributes.src;\n        }\n        delete attributes.src;\n    }\n    let isCustomElement;\n    try {\n        if (customElements.get(tagName))\n            isCustomElement = true;\n    }\n    catch (e) {\n    }\n    return {\n        type: NodeType$3.Element,\n        tagName,\n        attributes,\n        childNodes: [],\n        isSVG: isSVGElement(n) || undefined,\n        needBlock,\n        rootId,\n        isCustom: isCustomElement,\n    };\n}\nfunction lowerIfExists(maybeAttr) {\n    if (maybeAttr === undefined || maybeAttr === null) {\n        return '';\n    }\n    else {\n        return maybeAttr.toLowerCase();\n    }\n}\nfunction slimDOMExcluded(sn, slimDOMOptions) {\n    if (slimDOMOptions.comment && sn.type === NodeType$3.Comment) {\n        return true;\n    }\n    else if (sn.type === NodeType$3.Element) {\n        if (slimDOMOptions.script &&\n            (sn.tagName === 'script' ||\n                (sn.tagName === 'link' &&\n                    (sn.attributes.rel === 'preload' ||\n                        sn.attributes.rel === 'modulepreload')) ||\n                (sn.tagName === 'link' &&\n                    sn.attributes.rel === 'prefetch' &&\n                    typeof sn.attributes.href === 'string' &&\n                    extractFileExtension(sn.attributes.href) === 'js'))) {\n            return true;\n        }\n        else if (slimDOMOptions.headFavicon &&\n            ((sn.tagName === 'link' && sn.attributes.rel === 'shortcut icon') ||\n                (sn.tagName === 'meta' &&\n                    (lowerIfExists(sn.attributes.name).match(/^msapplication-tile(image|color)$/) ||\n                        lowerIfExists(sn.attributes.name) === 'application-name' ||\n                        lowerIfExists(sn.attributes.rel) === 'icon' ||\n                        lowerIfExists(sn.attributes.rel) === 'apple-touch-icon' ||\n                        lowerIfExists(sn.attributes.rel) === 'shortcut icon')))) {\n            return true;\n        }\n        else if (sn.tagName === 'meta') {\n            if (slimDOMOptions.headMetaDescKeywords &&\n                lowerIfExists(sn.attributes.name).match(/^description|keywords$/)) {\n                return true;\n            }\n            else if (slimDOMOptions.headMetaSocial &&\n                (lowerIfExists(sn.attributes.property).match(/^(og|twitter|fb):/) ||\n                    lowerIfExists(sn.attributes.name).match(/^(og|twitter):/) ||\n                    lowerIfExists(sn.attributes.name) === 'pinterest')) {\n                return true;\n            }\n            else if (slimDOMOptions.headMetaRobots &&\n                (lowerIfExists(sn.attributes.name) === 'robots' ||\n                    lowerIfExists(sn.attributes.name) === 'googlebot' ||\n                    lowerIfExists(sn.attributes.name) === 'bingbot')) {\n                return true;\n            }\n            else if (slimDOMOptions.headMetaHttpEquiv &&\n                sn.attributes['http-equiv'] !== undefined) {\n                return true;\n            }\n            else if (slimDOMOptions.headMetaAuthorship &&\n                (lowerIfExists(sn.attributes.name) === 'author' ||\n                    lowerIfExists(sn.attributes.name) === 'generator' ||\n                    lowerIfExists(sn.attributes.name) === 'framework' ||\n                    lowerIfExists(sn.attributes.name) === 'publisher' ||\n                    lowerIfExists(sn.attributes.name) === 'progid' ||\n                    lowerIfExists(sn.attributes.property).match(/^article:/) ||\n                    lowerIfExists(sn.attributes.property).match(/^product:/))) {\n                return true;\n            }\n            else if (slimDOMOptions.headMetaVerification &&\n                (lowerIfExists(sn.attributes.name) === 'google-site-verification' ||\n                    lowerIfExists(sn.attributes.name) === 'yandex-verification' ||\n                    lowerIfExists(sn.attributes.name) === 'csrf-token' ||\n                    lowerIfExists(sn.attributes.name) === 'p:domain_verify' ||\n                    lowerIfExists(sn.attributes.name) === 'verify-v1' ||\n                    lowerIfExists(sn.attributes.name) === 'verification' ||\n                    lowerIfExists(sn.attributes.name) === 'shopify-checkout-api-token')) {\n                return true;\n            }\n        }\n    }\n    return false;\n}\nfunction serializeNodeWithId(n, options) {\n    const { doc, mirror, blockClass, blockSelector, unblockSelector, maskAllText, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, skipChild = false, inlineStylesheet = true, maskInputOptions = {}, maskAttributeFn, maskTextFn, maskInputFn, slimDOMOptions, dataURLOptions = {}, inlineImages = false, recordCanvas = false, onSerialize, onIframeLoad, iframeLoadTimeout = 5000, onStylesheetLoad, stylesheetLoadTimeout = 5000, keepIframeSrcFn = () => false, newlyAddedElement = false, } = options;\n    let { preserveWhiteSpace = true } = options;\n    const _serializedNode = serializeNode(n, {\n        doc,\n        mirror,\n        blockClass,\n        blockSelector,\n        maskAllText,\n        unblockSelector,\n        maskTextClass,\n        unmaskTextClass,\n        maskTextSelector,\n        unmaskTextSelector,\n        inlineStylesheet,\n        maskInputOptions,\n        maskAttributeFn,\n        maskTextFn,\n        maskInputFn,\n        dataURLOptions,\n        inlineImages,\n        recordCanvas,\n        keepIframeSrcFn,\n        newlyAddedElement,\n    });\n    if (!_serializedNode) {\n        console.warn(n, 'not serialized');\n        return null;\n    }\n    let id;\n    if (mirror.hasNode(n)) {\n        id = mirror.getId(n);\n    }\n    else if (slimDOMExcluded(_serializedNode, slimDOMOptions) ||\n        (!preserveWhiteSpace &&\n            _serializedNode.type === NodeType$3.Text &&\n            !_serializedNode.isStyle &&\n            !_serializedNode.textContent.replace(/^\\s+|\\s+$/gm, '').length)) {\n        id = IGNORED_NODE;\n    }\n    else {\n        id = genId();\n    }\n    const serializedNode = Object.assign(_serializedNode, { id });\n    mirror.add(n, serializedNode);\n    if (id === IGNORED_NODE) {\n        return null;\n    }\n    if (onSerialize) {\n        onSerialize(n);\n    }\n    let recordChild = !skipChild;\n    if (serializedNode.type === NodeType$3.Element) {\n        recordChild = recordChild && !serializedNode.needBlock;\n        delete serializedNode.needBlock;\n        const shadowRoot = n.shadowRoot;\n        if (shadowRoot && isNativeShadowDom(shadowRoot))\n            serializedNode.isShadowHost = true;\n    }\n    if ((serializedNode.type === NodeType$3.Document ||\n        serializedNode.type === NodeType$3.Element) &&\n        recordChild) {\n        if (slimDOMOptions.headWhitespace &&\n            serializedNode.type === NodeType$3.Element &&\n            serializedNode.tagName === 'head') {\n            preserveWhiteSpace = false;\n        }\n        const bypassOptions = {\n            doc,\n            mirror,\n            blockClass,\n            blockSelector,\n            maskAllText,\n            unblockSelector,\n            maskTextClass,\n            unmaskTextClass,\n            maskTextSelector,\n            unmaskTextSelector,\n            skipChild,\n            inlineStylesheet,\n            maskInputOptions,\n            maskAttributeFn,\n            maskTextFn,\n            maskInputFn,\n            slimDOMOptions,\n            dataURLOptions,\n            inlineImages,\n            recordCanvas,\n            preserveWhiteSpace,\n            onSerialize,\n            onIframeLoad,\n            iframeLoadTimeout,\n            onStylesheetLoad,\n            stylesheetLoadTimeout,\n            keepIframeSrcFn,\n        };\n        for (const childN of Array.from(n.childNodes)) {\n            const serializedChildNode = serializeNodeWithId(childN, bypassOptions);\n            if (serializedChildNode) {\n                serializedNode.childNodes.push(serializedChildNode);\n            }\n        }\n        if (isElement$1(n) && n.shadowRoot) {\n            for (const childN of Array.from(n.shadowRoot.childNodes)) {\n                const serializedChildNode = serializeNodeWithId(childN, bypassOptions);\n                if (serializedChildNode) {\n                    isNativeShadowDom(n.shadowRoot) &&\n                        (serializedChildNode.isShadow = true);\n                    serializedNode.childNodes.push(serializedChildNode);\n                }\n            }\n        }\n    }\n    if (n.parentNode &&\n        isShadowRoot(n.parentNode) &&\n        isNativeShadowDom(n.parentNode)) {\n        serializedNode.isShadow = true;\n    }\n    if (serializedNode.type === NodeType$3.Element &&\n        serializedNode.tagName === 'iframe') {\n        onceIframeLoaded(n, () => {\n            const iframeDoc = getIframeContentDocument(n);\n            if (iframeDoc && onIframeLoad) {\n                const serializedIframeNode = serializeNodeWithId(iframeDoc, {\n                    doc: iframeDoc,\n                    mirror,\n                    blockClass,\n                    blockSelector,\n                    unblockSelector,\n                    maskAllText,\n                    maskTextClass,\n                    unmaskTextClass,\n                    maskTextSelector,\n                    unmaskTextSelector,\n                    skipChild: false,\n                    inlineStylesheet,\n                    maskInputOptions,\n                    maskAttributeFn,\n                    maskTextFn,\n                    maskInputFn,\n                    slimDOMOptions,\n                    dataURLOptions,\n                    inlineImages,\n                    recordCanvas,\n                    preserveWhiteSpace,\n                    onSerialize,\n                    onIframeLoad,\n                    iframeLoadTimeout,\n                    onStylesheetLoad,\n                    stylesheetLoadTimeout,\n                    keepIframeSrcFn,\n                });\n                if (serializedIframeNode) {\n                    onIframeLoad(n, serializedIframeNode);\n                }\n            }\n        }, iframeLoadTimeout);\n    }\n    if (serializedNode.type === NodeType$3.Element &&\n        serializedNode.tagName === 'link' &&\n        typeof serializedNode.attributes.rel === 'string' &&\n        (serializedNode.attributes.rel === 'stylesheet' ||\n            (serializedNode.attributes.rel === 'preload' &&\n                typeof serializedNode.attributes.href === 'string' &&\n                extractFileExtension(serializedNode.attributes.href) === 'css'))) {\n        onceStylesheetLoaded(n, () => {\n            if (onStylesheetLoad) {\n                const serializedLinkNode = serializeNodeWithId(n, {\n                    doc,\n                    mirror,\n                    blockClass,\n                    blockSelector,\n                    unblockSelector,\n                    maskAllText,\n                    maskTextClass,\n                    unmaskTextClass,\n                    maskTextSelector,\n                    unmaskTextSelector,\n                    skipChild: false,\n                    inlineStylesheet,\n                    maskInputOptions,\n                    maskAttributeFn,\n                    maskTextFn,\n                    maskInputFn,\n                    slimDOMOptions,\n                    dataURLOptions,\n                    inlineImages,\n                    recordCanvas,\n                    preserveWhiteSpace,\n                    onSerialize,\n                    onIframeLoad,\n                    iframeLoadTimeout,\n                    onStylesheetLoad,\n                    stylesheetLoadTimeout,\n                    keepIframeSrcFn,\n                });\n                if (serializedLinkNode) {\n                    onStylesheetLoad(n, serializedLinkNode);\n                }\n            }\n        }, stylesheetLoadTimeout);\n    }\n    return serializedNode;\n}\nfunction snapshot(n, options) {\n    const { mirror = new Mirror(), blockClass = 'rr-block', blockSelector = null, unblockSelector = null, maskAllText = false, maskTextClass = 'rr-mask', unmaskTextClass = null, maskTextSelector = null, unmaskTextSelector = null, inlineStylesheet = true, inlineImages = false, recordCanvas = false, maskAllInputs = false, maskAttributeFn, maskTextFn, maskInputFn, slimDOM = false, dataURLOptions, preserveWhiteSpace, onSerialize, onIframeLoad, iframeLoadTimeout, onStylesheetLoad, stylesheetLoadTimeout, keepIframeSrcFn = () => false, } = options;\n    const maskInputOptions = maskAllInputs === true\n        ? {\n            color: true,\n            date: true,\n            'datetime-local': true,\n            email: true,\n            month: true,\n            number: true,\n            range: true,\n            search: true,\n            tel: true,\n            text: true,\n            time: true,\n            url: true,\n            week: true,\n            textarea: true,\n            select: true,\n        }\n        : maskAllInputs === false\n            ? {}\n            : maskAllInputs;\n    const slimDOMOptions = slimDOM === true || slimDOM === 'all'\n        ?\n            {\n                script: true,\n                comment: true,\n                headFavicon: true,\n                headWhitespace: true,\n                headMetaDescKeywords: slimDOM === 'all',\n                headMetaSocial: true,\n                headMetaRobots: true,\n                headMetaHttpEquiv: true,\n                headMetaAuthorship: true,\n                headMetaVerification: true,\n            }\n        : slimDOM === false\n            ? {}\n            : slimDOM;\n    return serializeNodeWithId(n, {\n        doc: n,\n        mirror,\n        blockClass,\n        blockSelector,\n        unblockSelector,\n        maskAllText,\n        maskTextClass,\n        unmaskTextClass,\n        maskTextSelector,\n        unmaskTextSelector,\n        skipChild: false,\n        inlineStylesheet,\n        maskInputOptions,\n        maskAttributeFn,\n        maskTextFn,\n        maskInputFn,\n        slimDOMOptions,\n        dataURLOptions,\n        inlineImages,\n        recordCanvas,\n        preserveWhiteSpace,\n        onSerialize,\n        onIframeLoad,\n        iframeLoadTimeout,\n        onStylesheetLoad,\n        stylesheetLoadTimeout,\n        keepIframeSrcFn,\n        newlyAddedElement: false,\n    });\n}\n\nfunction on(type, fn, target = document) {\n    const options = { capture: true, passive: true };\n    target.addEventListener(type, fn, options);\n    return () => target.removeEventListener(type, fn, options);\n}\nconst DEPARTED_MIRROR_ACCESS_WARNING = 'Please stop import mirror directly. Instead of that,' +\n    '\\r\\n' +\n    'now you can use replayer.getMirror() to access the mirror instance of a replayer,' +\n    '\\r\\n' +\n    'or you can use record.mirror to access the mirror instance during recording.';\nlet _mirror = {\n    map: {},\n    getId() {\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n        return -1;\n    },\n    getNode() {\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n        return null;\n    },\n    removeNodeFromMap() {\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n    },\n    has() {\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n        return false;\n    },\n    reset() {\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n    },\n};\nif (typeof window !== 'undefined' && window.Proxy && window.Reflect) {\n    _mirror = new Proxy(_mirror, {\n        get(target, prop, receiver) {\n            if (prop === 'map') {\n                console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n            }\n            return Reflect.get(target, prop, receiver);\n        },\n    });\n}\nfunction throttle$1(func, wait, options = {}) {\n    let timeout = null;\n    let previous = 0;\n    return function (...args) {\n        const now = Date.now();\n        if (!previous && options.leading === false) {\n            previous = now;\n        }\n        const remaining = wait - (now - previous);\n        const context = this;\n        if (remaining <= 0 || remaining > wait) {\n            if (timeout) {\n                clearTimeout$1(timeout);\n                timeout = null;\n            }\n            previous = now;\n            func.apply(context, args);\n        }\n        else if (!timeout && options.trailing !== false) {\n            timeout = setTimeout$1(() => {\n                previous = options.leading === false ? 0 : Date.now();\n                timeout = null;\n                func.apply(context, args);\n            }, remaining);\n        }\n    };\n}\nfunction hookSetter(target, key, d, isRevoked, win = window) {\n    const original = win.Object.getOwnPropertyDescriptor(target, key);\n    win.Object.defineProperty(target, key, isRevoked\n        ? d\n        : {\n            set(value) {\n                setTimeout$1(() => {\n                    d.set.call(this, value);\n                }, 0);\n                if (original && original.set) {\n                    original.set.call(this, value);\n                }\n            },\n        });\n    return () => hookSetter(target, key, original || {}, true);\n}\nfunction patch(source, name, replacement) {\n    try {\n        if (!(name in source)) {\n            return () => {\n            };\n        }\n        const original = source[name];\n        const wrapped = replacement(original);\n        if (typeof wrapped === 'function') {\n            wrapped.prototype = wrapped.prototype || {};\n            Object.defineProperties(wrapped, {\n                __rrweb_original__: {\n                    enumerable: false,\n                    value: original,\n                },\n            });\n        }\n        source[name] = wrapped;\n        return () => {\n            source[name] = original;\n        };\n    }\n    catch {\n        return () => {\n        };\n    }\n}\nlet nowTimestamp = Date.now;\nif (!(/[1-9][0-9]{12}/.test(Date.now().toString()))) {\n    nowTimestamp = () => new Date().getTime();\n}\nfunction getWindowScroll(win) {\n    const doc = win.document;\n    return {\n        left: doc.scrollingElement\n            ? doc.scrollingElement.scrollLeft\n            : win.pageXOffset !== undefined\n                ? win.pageXOffset\n                : doc?.documentElement.scrollLeft ||\n                    doc?.body?.parentElement?.scrollLeft ||\n                    doc?.body?.scrollLeft ||\n                    0,\n        top: doc.scrollingElement\n            ? doc.scrollingElement.scrollTop\n            : win.pageYOffset !== undefined\n                ? win.pageYOffset\n                : doc?.documentElement.scrollTop ||\n                    doc?.body?.parentElement?.scrollTop ||\n                    doc?.body?.scrollTop ||\n                    0,\n    };\n}\nfunction getWindowHeight() {\n    return (window.innerHeight ||\n        (document.documentElement && document.documentElement.clientHeight) ||\n        (document.body && document.body.clientHeight));\n}\nfunction getWindowWidth() {\n    return (window.innerWidth ||\n        (document.documentElement && document.documentElement.clientWidth) ||\n        (document.body && document.body.clientWidth));\n}\nfunction closestElementOfNode(node) {\n    if (!node) {\n        return null;\n    }\n    const el = node.nodeType === node.ELEMENT_NODE\n        ? node\n        : node.parentElement;\n    return el;\n}\nfunction isBlocked(node, blockClass, blockSelector, unblockSelector, checkAncestors) {\n    if (!node) {\n        return false;\n    }\n    const el = closestElementOfNode(node);\n    if (!el) {\n        return false;\n    }\n    const blockedPredicate = createMatchPredicate(blockClass, blockSelector);\n    if (!checkAncestors) {\n        const isUnblocked = unblockSelector && el.matches(unblockSelector);\n        return blockedPredicate(el) && !isUnblocked;\n    }\n    const blockDistance = distanceToMatch(el, blockedPredicate);\n    let unblockDistance = -1;\n    if (blockDistance < 0) {\n        return false;\n    }\n    if (unblockSelector) {\n        unblockDistance = distanceToMatch(el, createMatchPredicate(null, unblockSelector));\n    }\n    if (blockDistance > -1 && unblockDistance < 0) {\n        return true;\n    }\n    return blockDistance < unblockDistance;\n}\nfunction isSerialized(n, mirror) {\n    return mirror.getId(n) !== -1;\n}\nfunction isIgnored(n, mirror) {\n    return mirror.getId(n) === IGNORED_NODE;\n}\nfunction isAncestorRemoved(target, mirror) {\n    if (isShadowRoot(target)) {\n        return false;\n    }\n    const id = mirror.getId(target);\n    if (!mirror.has(id)) {\n        return true;\n    }\n    if (target.parentNode &&\n        target.parentNode.nodeType === target.DOCUMENT_NODE) {\n        return false;\n    }\n    if (!target.parentNode) {\n        return true;\n    }\n    return isAncestorRemoved(target.parentNode, mirror);\n}\nfunction legacy_isTouchEvent(event) {\n    return Boolean(event.changedTouches);\n}\nfunction polyfill(win = window) {\n    if ('NodeList' in win && !win.NodeList.prototype.forEach) {\n        win.NodeList.prototype.forEach = Array.prototype\n            .forEach;\n    }\n    if ('DOMTokenList' in win && !win.DOMTokenList.prototype.forEach) {\n        win.DOMTokenList.prototype.forEach = Array.prototype\n            .forEach;\n    }\n    if (!Node.prototype.contains) {\n        Node.prototype.contains = (...args) => {\n            let node = args[0];\n            if (!(0 in args)) {\n                throw new TypeError('1 argument is required');\n            }\n            do {\n                if (this === node) {\n                    return true;\n                }\n            } while ((node = node && node.parentNode));\n            return false;\n        };\n    }\n}\nfunction isSerializedIframe(n, mirror) {\n    return Boolean(n.nodeName === 'IFRAME' && mirror.getMeta(n));\n}\nfunction isSerializedStylesheet(n, mirror) {\n    return Boolean(n.nodeName === 'LINK' &&\n        n.nodeType === n.ELEMENT_NODE &&\n        n.getAttribute &&\n        n.getAttribute('rel') === 'stylesheet' &&\n        mirror.getMeta(n));\n}\nfunction hasShadowRoot(n) {\n    return Boolean(n?.shadowRoot);\n}\nclass StyleSheetMirror {\n    constructor() {\n        this.id = 1;\n        this.styleIDMap = new WeakMap();\n        this.idStyleMap = new Map();\n    }\n    getId(stylesheet) {\n        return this.styleIDMap.get(stylesheet) ?? -1;\n    }\n    has(stylesheet) {\n        return this.styleIDMap.has(stylesheet);\n    }\n    add(stylesheet, id) {\n        if (this.has(stylesheet))\n            return this.getId(stylesheet);\n        let newId;\n        if (id === undefined) {\n            newId = this.id++;\n        }\n        else\n            newId = id;\n        this.styleIDMap.set(stylesheet, newId);\n        this.idStyleMap.set(newId, stylesheet);\n        return newId;\n    }\n    getStyle(id) {\n        return this.idStyleMap.get(id) || null;\n    }\n    reset() {\n        this.styleIDMap = new WeakMap();\n        this.idStyleMap = new Map();\n        this.id = 1;\n    }\n    generateId() {\n        return this.id++;\n    }\n}\nfunction getShadowHost(n) {\n    let shadowHost = null;\n    if (n.getRootNode?.()?.nodeType === Node.DOCUMENT_FRAGMENT_NODE &&\n        n.getRootNode().host)\n        shadowHost = n.getRootNode().host;\n    return shadowHost;\n}\nfunction getRootShadowHost(n) {\n    let rootShadowHost = n;\n    let shadowHost;\n    while ((shadowHost = getShadowHost(rootShadowHost)))\n        rootShadowHost = shadowHost;\n    return rootShadowHost;\n}\nfunction shadowHostInDom(n) {\n    const doc = n.ownerDocument;\n    if (!doc)\n        return false;\n    const shadowHost = getRootShadowHost(n);\n    return doc.contains(shadowHost);\n}\nfunction inDom(n) {\n    const doc = n.ownerDocument;\n    if (!doc)\n        return false;\n    return doc.contains(n) || shadowHostInDom(n);\n}\nconst cachedImplementations = {};\nfunction getImplementation(name) {\n    const cached = cachedImplementations[name];\n    if (cached) {\n        return cached;\n    }\n    const document = window.document;\n    let impl = window[name];\n    if (document && typeof document.createElement === 'function') {\n        try {\n            const sandbox = document.createElement('iframe');\n            sandbox.hidden = true;\n            document.head.appendChild(sandbox);\n            const contentWindow = sandbox.contentWindow;\n            if (contentWindow && contentWindow[name]) {\n                impl =\n                    contentWindow[name];\n            }\n            document.head.removeChild(sandbox);\n        }\n        catch (e) {\n        }\n    }\n    return (cachedImplementations[name] = impl.bind(window));\n}\nfunction onRequestAnimationFrame(...rest) {\n    return getImplementation('requestAnimationFrame')(...rest);\n}\nfunction setTimeout$1(...rest) {\n    return getImplementation('setTimeout')(...rest);\n}\nfunction clearTimeout$1(...rest) {\n    return getImplementation('clearTimeout')(...rest);\n}\n\nvar EventType = /* @__PURE__ */ ((EventType2) => {\n  EventType2[EventType2[\"DomContentLoaded\"] = 0] = \"DomContentLoaded\";\n  EventType2[EventType2[\"Load\"] = 1] = \"Load\";\n  EventType2[EventType2[\"FullSnapshot\"] = 2] = \"FullSnapshot\";\n  EventType2[EventType2[\"IncrementalSnapshot\"] = 3] = \"IncrementalSnapshot\";\n  EventType2[EventType2[\"Meta\"] = 4] = \"Meta\";\n  EventType2[EventType2[\"Custom\"] = 5] = \"Custom\";\n  EventType2[EventType2[\"Plugin\"] = 6] = \"Plugin\";\n  return EventType2;\n})(EventType || {});\nvar IncrementalSource = /* @__PURE__ */ ((IncrementalSource2) => {\n  IncrementalSource2[IncrementalSource2[\"Mutation\"] = 0] = \"Mutation\";\n  IncrementalSource2[IncrementalSource2[\"MouseMove\"] = 1] = \"MouseMove\";\n  IncrementalSource2[IncrementalSource2[\"MouseInteraction\"] = 2] = \"MouseInteraction\";\n  IncrementalSource2[IncrementalSource2[\"Scroll\"] = 3] = \"Scroll\";\n  IncrementalSource2[IncrementalSource2[\"ViewportResize\"] = 4] = \"ViewportResize\";\n  IncrementalSource2[IncrementalSource2[\"Input\"] = 5] = \"Input\";\n  IncrementalSource2[IncrementalSource2[\"TouchMove\"] = 6] = \"TouchMove\";\n  IncrementalSource2[IncrementalSource2[\"MediaInteraction\"] = 7] = \"MediaInteraction\";\n  IncrementalSource2[IncrementalSource2[\"StyleSheetRule\"] = 8] = \"StyleSheetRule\";\n  IncrementalSource2[IncrementalSource2[\"CanvasMutation\"] = 9] = \"CanvasMutation\";\n  IncrementalSource2[IncrementalSource2[\"Font\"] = 10] = \"Font\";\n  IncrementalSource2[IncrementalSource2[\"Log\"] = 11] = \"Log\";\n  IncrementalSource2[IncrementalSource2[\"Drag\"] = 12] = \"Drag\";\n  IncrementalSource2[IncrementalSource2[\"StyleDeclaration\"] = 13] = \"StyleDeclaration\";\n  IncrementalSource2[IncrementalSource2[\"Selection\"] = 14] = \"Selection\";\n  IncrementalSource2[IncrementalSource2[\"AdoptedStyleSheet\"] = 15] = \"AdoptedStyleSheet\";\n  IncrementalSource2[IncrementalSource2[\"CustomElement\"] = 16] = \"CustomElement\";\n  return IncrementalSource2;\n})(IncrementalSource || {});\nvar MouseInteractions = /* @__PURE__ */ ((MouseInteractions2) => {\n  MouseInteractions2[MouseInteractions2[\"MouseUp\"] = 0] = \"MouseUp\";\n  MouseInteractions2[MouseInteractions2[\"MouseDown\"] = 1] = \"MouseDown\";\n  MouseInteractions2[MouseInteractions2[\"Click\"] = 2] = \"Click\";\n  MouseInteractions2[MouseInteractions2[\"ContextMenu\"] = 3] = \"ContextMenu\";\n  MouseInteractions2[MouseInteractions2[\"DblClick\"] = 4] = \"DblClick\";\n  MouseInteractions2[MouseInteractions2[\"Focus\"] = 5] = \"Focus\";\n  MouseInteractions2[MouseInteractions2[\"Blur\"] = 6] = \"Blur\";\n  MouseInteractions2[MouseInteractions2[\"TouchStart\"] = 7] = \"TouchStart\";\n  MouseInteractions2[MouseInteractions2[\"TouchMove_Departed\"] = 8] = \"TouchMove_Departed\";\n  MouseInteractions2[MouseInteractions2[\"TouchEnd\"] = 9] = \"TouchEnd\";\n  MouseInteractions2[MouseInteractions2[\"TouchCancel\"] = 10] = \"TouchCancel\";\n  return MouseInteractions2;\n})(MouseInteractions || {});\nvar PointerTypes = /* @__PURE__ */ ((PointerTypes2) => {\n  PointerTypes2[PointerTypes2[\"Mouse\"] = 0] = \"Mouse\";\n  PointerTypes2[PointerTypes2[\"Pen\"] = 1] = \"Pen\";\n  PointerTypes2[PointerTypes2[\"Touch\"] = 2] = \"Touch\";\n  return PointerTypes2;\n})(PointerTypes || {});\n\nvar NodeType$1;\n(function (NodeType) {\n    NodeType[NodeType[\"Document\"] = 0] = \"Document\";\n    NodeType[NodeType[\"DocumentType\"] = 1] = \"DocumentType\";\n    NodeType[NodeType[\"Element\"] = 2] = \"Element\";\n    NodeType[NodeType[\"Text\"] = 3] = \"Text\";\n    NodeType[NodeType[\"CDATA\"] = 4] = \"CDATA\";\n    NodeType[NodeType[\"Comment\"] = 5] = \"Comment\";\n})(NodeType$1 || (NodeType$1 = {}));\nvar NodeType$2;\n(function (NodeType) {\n    NodeType[NodeType[\"PLACEHOLDER\"] = 0] = \"PLACEHOLDER\";\n    NodeType[NodeType[\"ELEMENT_NODE\"] = 1] = \"ELEMENT_NODE\";\n    NodeType[NodeType[\"ATTRIBUTE_NODE\"] = 2] = \"ATTRIBUTE_NODE\";\n    NodeType[NodeType[\"TEXT_NODE\"] = 3] = \"TEXT_NODE\";\n    NodeType[NodeType[\"CDATA_SECTION_NODE\"] = 4] = \"CDATA_SECTION_NODE\";\n    NodeType[NodeType[\"ENTITY_REFERENCE_NODE\"] = 5] = \"ENTITY_REFERENCE_NODE\";\n    NodeType[NodeType[\"ENTITY_NODE\"] = 6] = \"ENTITY_NODE\";\n    NodeType[NodeType[\"PROCESSING_INSTRUCTION_NODE\"] = 7] = \"PROCESSING_INSTRUCTION_NODE\";\n    NodeType[NodeType[\"COMMENT_NODE\"] = 8] = \"COMMENT_NODE\";\n    NodeType[NodeType[\"DOCUMENT_NODE\"] = 9] = \"DOCUMENT_NODE\";\n    NodeType[NodeType[\"DOCUMENT_TYPE_NODE\"] = 10] = \"DOCUMENT_TYPE_NODE\";\n    NodeType[NodeType[\"DOCUMENT_FRAGMENT_NODE\"] = 11] = \"DOCUMENT_FRAGMENT_NODE\";\n})(NodeType$2 || (NodeType$2 = {}));\n\nfunction getIFrameContentDocument(iframe) {\n    try {\n        return iframe.contentDocument;\n    }\n    catch (e) {\n    }\n}\nfunction getIFrameContentWindow(iframe) {\n    try {\n        return iframe.contentWindow;\n    }\n    catch (e) {\n    }\n}\n\nfunction isNodeInLinkedList(n) {\n    return '__ln' in n;\n}\nclass DoubleLinkedList {\n    constructor() {\n        this.length = 0;\n        this.head = null;\n        this.tail = null;\n    }\n    get(position) {\n        if (position >= this.length) {\n            throw new Error('Position outside of list range');\n        }\n        let current = this.head;\n        for (let index = 0; index < position; index++) {\n            current = current?.next || null;\n        }\n        return current;\n    }\n    addNode(n) {\n        const node = {\n            value: n,\n            previous: null,\n            next: null,\n        };\n        n.__ln = node;\n        if (n.previousSibling && isNodeInLinkedList(n.previousSibling)) {\n            const current = n.previousSibling.__ln.next;\n            node.next = current;\n            node.previous = n.previousSibling.__ln;\n            n.previousSibling.__ln.next = node;\n            if (current) {\n                current.previous = node;\n            }\n        }\n        else if (n.nextSibling &&\n            isNodeInLinkedList(n.nextSibling) &&\n            n.nextSibling.__ln.previous) {\n            const current = n.nextSibling.__ln.previous;\n            node.previous = current;\n            node.next = n.nextSibling.__ln;\n            n.nextSibling.__ln.previous = node;\n            if (current) {\n                current.next = node;\n            }\n        }\n        else {\n            if (this.head) {\n                this.head.previous = node;\n            }\n            node.next = this.head;\n            this.head = node;\n        }\n        if (node.next === null) {\n            this.tail = node;\n        }\n        this.length++;\n    }\n    removeNode(n) {\n        const current = n.__ln;\n        if (!this.head) {\n            return;\n        }\n        if (!current.previous) {\n            this.head = current.next;\n            if (this.head) {\n                this.head.previous = null;\n            }\n            else {\n                this.tail = null;\n            }\n        }\n        else {\n            current.previous.next = current.next;\n            if (current.next) {\n                current.next.previous = current.previous;\n            }\n            else {\n                this.tail = current.previous;\n            }\n        }\n        if (n.__ln) {\n            delete n.__ln;\n        }\n        this.length--;\n    }\n}\nconst moveKey = (id, parentId) => `${id}@${parentId}`;\nclass MutationBuffer {\n    constructor() {\n        this.frozen = false;\n        this.locked = false;\n        this.texts = [];\n        this.attributes = [];\n        this.attributeMap = new WeakMap();\n        this.removes = [];\n        this.mapRemoves = [];\n        this.movedMap = {};\n        this.addedSet = new Set();\n        this.movedSet = new Set();\n        this.droppedSet = new Set();\n        this.processMutations = (mutations) => {\n            mutations.forEach(this.processMutation);\n            this.emit();\n        };\n        this.emit = () => {\n            if (this.frozen || this.locked) {\n                return;\n            }\n            const adds = [];\n            const addedIds = new Set();\n            const addList = new DoubleLinkedList();\n            const getNextId = (n) => {\n                let ns = n;\n                let nextId = IGNORED_NODE;\n                while (nextId === IGNORED_NODE) {\n                    ns = ns && ns.nextSibling;\n                    nextId = ns && this.mirror.getId(ns);\n                }\n                return nextId;\n            };\n            const pushAdd = (n) => {\n                if (!n.parentNode || !inDom(n)) {\n                    return;\n                }\n                const parentId = isShadowRoot(n.parentNode)\n                    ? this.mirror.getId(getShadowHost(n))\n                    : this.mirror.getId(n.parentNode);\n                const nextId = getNextId(n);\n                if (parentId === -1 || nextId === -1) {\n                    return addList.addNode(n);\n                }\n                const sn = serializeNodeWithId(n, {\n                    doc: this.doc,\n                    mirror: this.mirror,\n                    blockClass: this.blockClass,\n                    blockSelector: this.blockSelector,\n                    maskAllText: this.maskAllText,\n                    unblockSelector: this.unblockSelector,\n                    maskTextClass: this.maskTextClass,\n                    unmaskTextClass: this.unmaskTextClass,\n                    maskTextSelector: this.maskTextSelector,\n                    unmaskTextSelector: this.unmaskTextSelector,\n                    skipChild: true,\n                    newlyAddedElement: true,\n                    inlineStylesheet: this.inlineStylesheet,\n                    maskInputOptions: this.maskInputOptions,\n                    maskAttributeFn: this.maskAttributeFn,\n                    maskTextFn: this.maskTextFn,\n                    maskInputFn: this.maskInputFn,\n                    slimDOMOptions: this.slimDOMOptions,\n                    dataURLOptions: this.dataURLOptions,\n                    recordCanvas: this.recordCanvas,\n                    inlineImages: this.inlineImages,\n                    onSerialize: (currentN) => {\n                        if (isSerializedIframe(currentN, this.mirror) &&\n                            !isBlocked(currentN, this.blockClass, this.blockSelector, this.unblockSelector, false)) {\n                            this.iframeManager.addIframe(currentN);\n                        }\n                        if (isSerializedStylesheet(currentN, this.mirror)) {\n                            this.stylesheetManager.trackLinkElement(currentN);\n                        }\n                        if (hasShadowRoot(n)) {\n                            this.shadowDomManager.addShadowRoot(n.shadowRoot, this.doc);\n                        }\n                    },\n                    onIframeLoad: (iframe, childSn) => {\n                        if (isBlocked(iframe, this.blockClass, this.blockSelector, this.unblockSelector, false)) {\n                            return;\n                        }\n                        this.iframeManager.attachIframe(iframe, childSn);\n                        if (iframe.contentWindow) {\n                            this.canvasManager.addWindow(iframe.contentWindow);\n                        }\n                        this.shadowDomManager.observeAttachShadow(iframe);\n                    },\n                    onStylesheetLoad: (link, childSn) => {\n                        this.stylesheetManager.attachLinkElement(link, childSn);\n                    },\n                });\n                if (sn) {\n                    adds.push({\n                        parentId,\n                        nextId,\n                        node: sn,\n                    });\n                    addedIds.add(sn.id);\n                }\n            };\n            while (this.mapRemoves.length) {\n                this.mirror.removeNodeFromMap(this.mapRemoves.shift());\n            }\n            for (const n of this.movedSet) {\n                if (isParentRemoved(this.removes, n, this.mirror) &&\n                    !this.movedSet.has(n.parentNode)) {\n                    continue;\n                }\n                pushAdd(n);\n            }\n            for (const n of this.addedSet) {\n                if (!isAncestorInSet(this.droppedSet, n) &&\n                    !isParentRemoved(this.removes, n, this.mirror)) {\n                    pushAdd(n);\n                }\n                else if (isAncestorInSet(this.movedSet, n)) {\n                    pushAdd(n);\n                }\n                else {\n                    this.droppedSet.add(n);\n                }\n            }\n            let candidate = null;\n            while (addList.length) {\n                let node = null;\n                if (candidate) {\n                    const parentId = this.mirror.getId(candidate.value.parentNode);\n                    const nextId = getNextId(candidate.value);\n                    if (parentId !== -1 && nextId !== -1) {\n                        node = candidate;\n                    }\n                }\n                if (!node) {\n                    let tailNode = addList.tail;\n                    while (tailNode) {\n                        const _node = tailNode;\n                        tailNode = tailNode.previous;\n                        if (_node) {\n                            const parentId = this.mirror.getId(_node.value.parentNode);\n                            const nextId = getNextId(_node.value);\n                            if (nextId === -1)\n                                continue;\n                            else if (parentId !== -1) {\n                                node = _node;\n                                break;\n                            }\n                            else {\n                                const unhandledNode = _node.value;\n                                if (unhandledNode.parentNode &&\n                                    unhandledNode.parentNode.nodeType ===\n                                        Node.DOCUMENT_FRAGMENT_NODE) {\n                                    const shadowHost = unhandledNode.parentNode\n                                        .host;\n                                    const parentId = this.mirror.getId(shadowHost);\n                                    if (parentId !== -1) {\n                                        node = _node;\n                                        break;\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n                if (!node) {\n                    while (addList.head) {\n                        addList.removeNode(addList.head.value);\n                    }\n                    break;\n                }\n                candidate = node.previous;\n                addList.removeNode(node.value);\n                pushAdd(node.value);\n            }\n            const payload = {\n                texts: this.texts\n                    .map((text) => ({\n                    id: this.mirror.getId(text.node),\n                    value: text.value,\n                }))\n                    .filter((text) => !addedIds.has(text.id))\n                    .filter((text) => this.mirror.has(text.id)),\n                attributes: this.attributes\n                    .map((attribute) => {\n                    const { attributes } = attribute;\n                    if (typeof attributes.style === 'string') {\n                        const diffAsStr = JSON.stringify(attribute.styleDiff);\n                        const unchangedAsStr = JSON.stringify(attribute._unchangedStyles);\n                        if (diffAsStr.length < attributes.style.length) {\n                            if ((diffAsStr + unchangedAsStr).split('var(').length ===\n                                attributes.style.split('var(').length) {\n                                attributes.style = attribute.styleDiff;\n                            }\n                        }\n                    }\n                    return {\n                        id: this.mirror.getId(attribute.node),\n                        attributes: attributes,\n                    };\n                })\n                    .filter((attribute) => !addedIds.has(attribute.id))\n                    .filter((attribute) => this.mirror.has(attribute.id)),\n                removes: this.removes,\n                adds,\n            };\n            if (!payload.texts.length &&\n                !payload.attributes.length &&\n                !payload.removes.length &&\n                !payload.adds.length) {\n                return;\n            }\n            this.texts = [];\n            this.attributes = [];\n            this.attributeMap = new WeakMap();\n            this.removes = [];\n            this.addedSet = new Set();\n            this.movedSet = new Set();\n            this.droppedSet = new Set();\n            this.movedMap = {};\n            this.mutationCb(payload);\n        };\n        this.processMutation = (m) => {\n            if (isIgnored(m.target, this.mirror)) {\n                return;\n            }\n            switch (m.type) {\n                case 'characterData': {\n                    const value = m.target.textContent;\n                    if (!isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, false) &&\n                        value !== m.oldValue) {\n                        this.texts.push({\n                            value: needMaskingText(m.target, this.maskTextClass, this.maskTextSelector, this.unmaskTextClass, this.unmaskTextSelector, this.maskAllText) && value\n                                ? this.maskTextFn\n                                    ? this.maskTextFn(value, closestElementOfNode(m.target))\n                                    : value.replace(/[\\S]/g, '*')\n                                : value,\n                            node: m.target,\n                        });\n                    }\n                    break;\n                }\n                case 'attributes': {\n                    const target = m.target;\n                    let attributeName = m.attributeName;\n                    let value = m.target.getAttribute(attributeName);\n                    if (attributeName === 'value') {\n                        const type = getInputType(target);\n                        const tagName = target.tagName;\n                        value = getInputValue(target, tagName, type);\n                        const isInputMasked = shouldMaskInput({\n                            maskInputOptions: this.maskInputOptions,\n                            tagName,\n                            type,\n                        });\n                        const forceMask = needMaskingText(m.target, this.maskTextClass, this.maskTextSelector, this.unmaskTextClass, this.unmaskTextSelector, isInputMasked);\n                        value = maskInputValue({\n                            isMasked: forceMask,\n                            element: target,\n                            value,\n                            maskInputFn: this.maskInputFn,\n                        });\n                    }\n                    if (isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, false) ||\n                        value === m.oldValue) {\n                        return;\n                    }\n                    let item = this.attributeMap.get(m.target);\n                    if (target.tagName === 'IFRAME' &&\n                        attributeName === 'src' &&\n                        !this.keepIframeSrcFn(value)) {\n                        const iframeDoc = getIFrameContentDocument(target);\n                        if (!iframeDoc) {\n                            attributeName = 'rr_src';\n                        }\n                        else {\n                            return;\n                        }\n                    }\n                    if (!item) {\n                        item = {\n                            node: m.target,\n                            attributes: {},\n                            styleDiff: {},\n                            _unchangedStyles: {},\n                        };\n                        this.attributes.push(item);\n                        this.attributeMap.set(m.target, item);\n                    }\n                    if (attributeName === 'type' &&\n                        target.tagName === 'INPUT' &&\n                        (m.oldValue || '').toLowerCase() === 'password') {\n                        target.setAttribute('data-rr-is-password', 'true');\n                    }\n                    if (!ignoreAttribute(target.tagName, attributeName)) {\n                        item.attributes[attributeName] = transformAttribute(this.doc, toLowerCase(target.tagName), toLowerCase(attributeName), value, target, this.maskAttributeFn);\n                        if (attributeName === 'style') {\n                            if (!this.unattachedDoc) {\n                                try {\n                                    this.unattachedDoc =\n                                        document.implementation.createHTMLDocument();\n                                }\n                                catch (e) {\n                                    this.unattachedDoc = this.doc;\n                                }\n                            }\n                            const old = this.unattachedDoc.createElement('span');\n                            if (m.oldValue) {\n                                old.setAttribute('style', m.oldValue);\n                            }\n                            for (const pname of Array.from(target.style)) {\n                                const newValue = target.style.getPropertyValue(pname);\n                                const newPriority = target.style.getPropertyPriority(pname);\n                                if (newValue !== old.style.getPropertyValue(pname) ||\n                                    newPriority !== old.style.getPropertyPriority(pname)) {\n                                    if (newPriority === '') {\n                                        item.styleDiff[pname] = newValue;\n                                    }\n                                    else {\n                                        item.styleDiff[pname] = [newValue, newPriority];\n                                    }\n                                }\n                                else {\n                                    item._unchangedStyles[pname] = [newValue, newPriority];\n                                }\n                            }\n                            for (const pname of Array.from(old.style)) {\n                                if (target.style.getPropertyValue(pname) === '') {\n                                    item.styleDiff[pname] = false;\n                                }\n                            }\n                        }\n                    }\n                    break;\n                }\n                case 'childList': {\n                    if (isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, true)) {\n                        return;\n                    }\n                    m.addedNodes.forEach((n) => this.genAdds(n, m.target));\n                    m.removedNodes.forEach((n) => {\n                        const nodeId = this.mirror.getId(n);\n                        const parentId = isShadowRoot(m.target)\n                            ? this.mirror.getId(m.target.host)\n                            : this.mirror.getId(m.target);\n                        if (isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, false) ||\n                            isIgnored(n, this.mirror) ||\n                            !isSerialized(n, this.mirror)) {\n                            return;\n                        }\n                        if (this.addedSet.has(n)) {\n                            deepDelete(this.addedSet, n);\n                            this.droppedSet.add(n);\n                        }\n                        else if (this.addedSet.has(m.target) && nodeId === -1) ;\n                        else if (isAncestorRemoved(m.target, this.mirror)) ;\n                        else if (this.movedSet.has(n) &&\n                            this.movedMap[moveKey(nodeId, parentId)]) {\n                            deepDelete(this.movedSet, n);\n                        }\n                        else {\n                            this.removes.push({\n                                parentId,\n                                id: nodeId,\n                                isShadow: isShadowRoot(m.target) && isNativeShadowDom(m.target)\n                                    ? true\n                                    : undefined,\n                            });\n                        }\n                        this.mapRemoves.push(n);\n                    });\n                    break;\n                }\n            }\n        };\n        this.genAdds = (n, target) => {\n            if (this.processedNodeManager.inOtherBuffer(n, this))\n                return;\n            if (this.addedSet.has(n) || this.movedSet.has(n))\n                return;\n            if (this.mirror.hasNode(n)) {\n                if (isIgnored(n, this.mirror)) {\n                    return;\n                }\n                this.movedSet.add(n);\n                let targetId = null;\n                if (target && this.mirror.hasNode(target)) {\n                    targetId = this.mirror.getId(target);\n                }\n                if (targetId && targetId !== -1) {\n                    this.movedMap[moveKey(this.mirror.getId(n), targetId)] = true;\n                }\n            }\n            else {\n                this.addedSet.add(n);\n                this.droppedSet.delete(n);\n            }\n            if (!isBlocked(n, this.blockClass, this.blockSelector, this.unblockSelector, false)) {\n                n.childNodes.forEach((childN) => this.genAdds(childN));\n                if (hasShadowRoot(n)) {\n                    n.shadowRoot.childNodes.forEach((childN) => {\n                        this.processedNodeManager.add(childN, this);\n                        this.genAdds(childN, n);\n                    });\n                }\n            }\n        };\n    }\n    init(options) {\n        [\n            'mutationCb',\n            'blockClass',\n            'blockSelector',\n            'unblockSelector',\n            'maskAllText',\n            'maskTextClass',\n            'unmaskTextClass',\n            'maskTextSelector',\n            'unmaskTextSelector',\n            'inlineStylesheet',\n            'maskInputOptions',\n            'maskAttributeFn',\n            'maskTextFn',\n            'maskInputFn',\n            'keepIframeSrcFn',\n            'recordCanvas',\n            'inlineImages',\n            'slimDOMOptions',\n            'dataURLOptions',\n            'doc',\n            'mirror',\n            'iframeManager',\n            'stylesheetManager',\n            'shadowDomManager',\n            'canvasManager',\n            'processedNodeManager',\n        ].forEach((key) => {\n            this[key] = options[key];\n        });\n    }\n    freeze() {\n        this.frozen = true;\n        this.canvasManager.freeze();\n    }\n    unfreeze() {\n        this.frozen = false;\n        this.canvasManager.unfreeze();\n        this.emit();\n    }\n    isFrozen() {\n        return this.frozen;\n    }\n    lock() {\n        this.locked = true;\n        this.canvasManager.lock();\n    }\n    unlock() {\n        this.locked = false;\n        this.canvasManager.unlock();\n        this.emit();\n    }\n    reset() {\n        this.shadowDomManager.reset();\n        this.canvasManager.reset();\n    }\n}\nfunction deepDelete(addsSet, n) {\n    addsSet.delete(n);\n    n.childNodes.forEach((childN) => deepDelete(addsSet, childN));\n}\nfunction isParentRemoved(removes, n, mirror) {\n    if (removes.length === 0)\n        return false;\n    return _isParentRemoved(removes, n, mirror);\n}\nfunction _isParentRemoved(removes, n, mirror) {\n    let node = n.parentNode;\n    while (node) {\n        const parentId = mirror.getId(node);\n        if (removes.some((r) => r.id === parentId)) {\n            return true;\n        }\n        node = node.parentNode;\n    }\n    return false;\n}\nfunction isAncestorInSet(set, n) {\n    if (set.size === 0)\n        return false;\n    return _isAncestorInSet(set, n);\n}\nfunction _isAncestorInSet(set, n) {\n    const { parentNode } = n;\n    if (!parentNode) {\n        return false;\n    }\n    if (set.has(parentNode)) {\n        return true;\n    }\n    return _isAncestorInSet(set, parentNode);\n}\n\nlet errorHandler;\nfunction registerErrorHandler(handler) {\n    errorHandler = handler;\n}\nfunction unregisterErrorHandler() {\n    errorHandler = undefined;\n}\nconst callbackWrapper = (cb) => {\n    if (!errorHandler) {\n        return cb;\n    }\n    const rrwebWrapped = ((...rest) => {\n        try {\n            return cb(...rest);\n        }\n        catch (error) {\n            if (errorHandler && errorHandler(error) === true) {\n                return () => {\n                };\n            }\n            throw error;\n        }\n    });\n    return rrwebWrapped;\n};\n\nconst mutationBuffers = [];\nfunction getEventTarget(event) {\n    try {\n        if ('composedPath' in event) {\n            const path = event.composedPath();\n            if (path.length) {\n                return path[0];\n            }\n        }\n        else if ('path' in event && event.path.length) {\n            return event.path[0];\n        }\n    }\n    catch {\n    }\n    return event && event.target;\n}\nfunction initMutationObserver(options, rootEl) {\n    const mutationBuffer = new MutationBuffer();\n    mutationBuffers.push(mutationBuffer);\n    mutationBuffer.init(options);\n    let mutationObserverCtor = window.MutationObserver ||\n        window.__rrMutationObserver;\n    const angularZoneSymbol = window?.Zone?.__symbol__?.('MutationObserver');\n    if (angularZoneSymbol &&\n        window[angularZoneSymbol]) {\n        mutationObserverCtor = window[angularZoneSymbol];\n    }\n    const observer = new mutationObserverCtor(callbackWrapper((mutations) => {\n        if (options.onMutation && options.onMutation(mutations) === false) {\n            return;\n        }\n        mutationBuffer.processMutations.bind(mutationBuffer)(mutations);\n    }));\n    observer.observe(rootEl, {\n        attributes: true,\n        attributeOldValue: true,\n        characterData: true,\n        characterDataOldValue: true,\n        childList: true,\n        subtree: true,\n    });\n    return observer;\n}\nfunction initMoveObserver({ mousemoveCb, sampling, doc, mirror, }) {\n    if (sampling.mousemove === false) {\n        return () => {\n        };\n    }\n    const threshold = typeof sampling.mousemove === 'number' ? sampling.mousemove : 50;\n    const callbackThreshold = typeof sampling.mousemoveCallback === 'number'\n        ? sampling.mousemoveCallback\n        : 500;\n    let positions = [];\n    let timeBaseline;\n    const wrappedCb = throttle$1(callbackWrapper((source) => {\n        const totalOffset = Date.now() - timeBaseline;\n        mousemoveCb(positions.map((p) => {\n            p.timeOffset -= totalOffset;\n            return p;\n        }), source);\n        positions = [];\n        timeBaseline = null;\n    }), callbackThreshold);\n    const updatePosition = callbackWrapper(throttle$1(callbackWrapper((evt) => {\n        const target = getEventTarget(evt);\n        const { clientX, clientY } = legacy_isTouchEvent(evt)\n            ? evt.changedTouches[0]\n            : evt;\n        if (!timeBaseline) {\n            timeBaseline = nowTimestamp();\n        }\n        positions.push({\n            x: clientX,\n            y: clientY,\n            id: mirror.getId(target),\n            timeOffset: nowTimestamp() - timeBaseline,\n        });\n        wrappedCb(typeof DragEvent !== 'undefined' && evt instanceof DragEvent\n            ? IncrementalSource.Drag\n            : evt instanceof MouseEvent\n                ? IncrementalSource.MouseMove\n                : IncrementalSource.TouchMove);\n    }), threshold, {\n        trailing: false,\n    }));\n    const handlers = [\n        on('mousemove', updatePosition, doc),\n        on('touchmove', updatePosition, doc),\n        on('drag', updatePosition, doc),\n    ];\n    return callbackWrapper(() => {\n        handlers.forEach((h) => h());\n    });\n}\nfunction initMouseInteractionObserver({ mouseInteractionCb, doc, mirror, blockClass, blockSelector, unblockSelector, sampling, }) {\n    if (sampling.mouseInteraction === false) {\n        return () => {\n        };\n    }\n    const disableMap = sampling.mouseInteraction === true ||\n        sampling.mouseInteraction === undefined\n        ? {}\n        : sampling.mouseInteraction;\n    const handlers = [];\n    let currentPointerType = null;\n    const getHandler = (eventKey) => {\n        return (event) => {\n            const target = getEventTarget(event);\n            if (isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\n                return;\n            }\n            let pointerType = null;\n            let thisEventKey = eventKey;\n            if ('pointerType' in event) {\n                switch (event.pointerType) {\n                    case 'mouse':\n                        pointerType = PointerTypes.Mouse;\n                        break;\n                    case 'touch':\n                        pointerType = PointerTypes.Touch;\n                        break;\n                    case 'pen':\n                        pointerType = PointerTypes.Pen;\n                        break;\n                }\n                if (pointerType === PointerTypes.Touch) {\n                    if (MouseInteractions[eventKey] === MouseInteractions.MouseDown) {\n                        thisEventKey = 'TouchStart';\n                    }\n                    else if (MouseInteractions[eventKey] === MouseInteractions.MouseUp) {\n                        thisEventKey = 'TouchEnd';\n                    }\n                }\n                else if (pointerType === PointerTypes.Pen) ;\n            }\n            else if (legacy_isTouchEvent(event)) {\n                pointerType = PointerTypes.Touch;\n            }\n            if (pointerType !== null) {\n                currentPointerType = pointerType;\n                if ((thisEventKey.startsWith('Touch') &&\n                    pointerType === PointerTypes.Touch) ||\n                    (thisEventKey.startsWith('Mouse') &&\n                        pointerType === PointerTypes.Mouse)) {\n                    pointerType = null;\n                }\n            }\n            else if (MouseInteractions[eventKey] === MouseInteractions.Click) {\n                pointerType = currentPointerType;\n                currentPointerType = null;\n            }\n            const e = legacy_isTouchEvent(event) ? event.changedTouches[0] : event;\n            if (!e) {\n                return;\n            }\n            const id = mirror.getId(target);\n            const { clientX, clientY } = e;\n            callbackWrapper(mouseInteractionCb)({\n                type: MouseInteractions[thisEventKey],\n                id,\n                x: clientX,\n                y: clientY,\n                ...(pointerType !== null && { pointerType }),\n            });\n        };\n    };\n    Object.keys(MouseInteractions)\n        .filter((key) => Number.isNaN(Number(key)) &&\n        !key.endsWith('_Departed') &&\n        disableMap[key] !== false)\n        .forEach((eventKey) => {\n        let eventName = toLowerCase(eventKey);\n        const handler = getHandler(eventKey);\n        if (window.PointerEvent) {\n            switch (MouseInteractions[eventKey]) {\n                case MouseInteractions.MouseDown:\n                case MouseInteractions.MouseUp:\n                    eventName = eventName.replace('mouse', 'pointer');\n                    break;\n                case MouseInteractions.TouchStart:\n                case MouseInteractions.TouchEnd:\n                    return;\n            }\n        }\n        handlers.push(on(eventName, handler, doc));\n    });\n    return callbackWrapper(() => {\n        handlers.forEach((h) => h());\n    });\n}\nfunction initScrollObserver({ scrollCb, doc, mirror, blockClass, blockSelector, unblockSelector, sampling, }) {\n    const updatePosition = callbackWrapper(throttle$1(callbackWrapper((evt) => {\n        const target = getEventTarget(evt);\n        if (!target ||\n            isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\n            return;\n        }\n        const id = mirror.getId(target);\n        if (target === doc && doc.defaultView) {\n            const scrollLeftTop = getWindowScroll(doc.defaultView);\n            scrollCb({\n                id,\n                x: scrollLeftTop.left,\n                y: scrollLeftTop.top,\n            });\n        }\n        else {\n            scrollCb({\n                id,\n                x: target.scrollLeft,\n                y: target.scrollTop,\n            });\n        }\n    }), sampling.scroll || 100));\n    return on('scroll', updatePosition, doc);\n}\nfunction initViewportResizeObserver({ viewportResizeCb }, { win }) {\n    let lastH = -1;\n    let lastW = -1;\n    const updateDimension = callbackWrapper(throttle$1(callbackWrapper(() => {\n        const height = getWindowHeight();\n        const width = getWindowWidth();\n        if (lastH !== height || lastW !== width) {\n            viewportResizeCb({\n                width: Number(width),\n                height: Number(height),\n            });\n            lastH = height;\n            lastW = width;\n        }\n    }), 200));\n    return on('resize', updateDimension, win);\n}\nconst INPUT_TAGS = ['INPUT', 'TEXTAREA', 'SELECT'];\nconst lastInputValueMap = new WeakMap();\nfunction initInputObserver({ inputCb, doc, mirror, blockClass, blockSelector, unblockSelector, ignoreClass, ignoreSelector, maskInputOptions, maskInputFn, sampling, userTriggeredOnInput, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, }) {\n    function eventHandler(event) {\n        let target = getEventTarget(event);\n        const userTriggered = event.isTrusted;\n        const tagName = target && toUpperCase(target.tagName);\n        if (tagName === 'OPTION')\n            target = target.parentElement;\n        if (!target ||\n            !tagName ||\n            INPUT_TAGS.indexOf(tagName) < 0 ||\n            isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\n            return;\n        }\n        const el = target;\n        if (el.classList.contains(ignoreClass) ||\n            (ignoreSelector && el.matches(ignoreSelector))) {\n            return;\n        }\n        const type = getInputType(target);\n        let text = getInputValue(el, tagName, type);\n        let isChecked = false;\n        const isInputMasked = shouldMaskInput({\n            maskInputOptions,\n            tagName,\n            type,\n        });\n        const forceMask = needMaskingText(target, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, isInputMasked);\n        if (type === 'radio' || type === 'checkbox') {\n            isChecked = target.checked;\n        }\n        text = maskInputValue({\n            isMasked: forceMask,\n            element: target,\n            value: text,\n            maskInputFn,\n        });\n        cbWithDedup(target, userTriggeredOnInput\n            ? { text, isChecked, userTriggered }\n            : { text, isChecked });\n        const name = target.name;\n        if (type === 'radio' && name && isChecked) {\n            doc\n                .querySelectorAll(`input[type=\"radio\"][name=\"${name}\"]`)\n                .forEach((el) => {\n                if (el !== target) {\n                    const text = maskInputValue({\n                        isMasked: forceMask,\n                        element: el,\n                        value: getInputValue(el, tagName, type),\n                        maskInputFn,\n                    });\n                    cbWithDedup(el, userTriggeredOnInput\n                        ? { text, isChecked: !isChecked, userTriggered: false }\n                        : { text, isChecked: !isChecked });\n                }\n            });\n        }\n    }\n    function cbWithDedup(target, v) {\n        const lastInputValue = lastInputValueMap.get(target);\n        if (!lastInputValue ||\n            lastInputValue.text !== v.text ||\n            lastInputValue.isChecked !== v.isChecked) {\n            lastInputValueMap.set(target, v);\n            const id = mirror.getId(target);\n            callbackWrapper(inputCb)({\n                ...v,\n                id,\n            });\n        }\n    }\n    const events = sampling.input === 'last' ? ['change'] : ['input', 'change'];\n    const handlers = events.map((eventName) => on(eventName, callbackWrapper(eventHandler), doc));\n    const currentWindow = doc.defaultView;\n    if (!currentWindow) {\n        return () => {\n            handlers.forEach((h) => h());\n        };\n    }\n    const propertyDescriptor = currentWindow.Object.getOwnPropertyDescriptor(currentWindow.HTMLInputElement.prototype, 'value');\n    const hookProperties = [\n        [currentWindow.HTMLInputElement.prototype, 'value'],\n        [currentWindow.HTMLInputElement.prototype, 'checked'],\n        [currentWindow.HTMLSelectElement.prototype, 'value'],\n        [currentWindow.HTMLTextAreaElement.prototype, 'value'],\n        [currentWindow.HTMLSelectElement.prototype, 'selectedIndex'],\n        [currentWindow.HTMLOptionElement.prototype, 'selected'],\n    ];\n    if (propertyDescriptor && propertyDescriptor.set) {\n        handlers.push(...hookProperties.map((p) => hookSetter(p[0], p[1], {\n            set() {\n                callbackWrapper(eventHandler)({\n                    target: this,\n                    isTrusted: false,\n                });\n            },\n        }, false, currentWindow)));\n    }\n    return callbackWrapper(() => {\n        handlers.forEach((h) => h());\n    });\n}\nfunction getNestedCSSRulePositions(rule) {\n    const positions = [];\n    function recurse(childRule, pos) {\n        if ((hasNestedCSSRule('CSSGroupingRule') &&\n            childRule.parentRule instanceof CSSGroupingRule) ||\n            (hasNestedCSSRule('CSSMediaRule') &&\n                childRule.parentRule instanceof CSSMediaRule) ||\n            (hasNestedCSSRule('CSSSupportsRule') &&\n                childRule.parentRule instanceof CSSSupportsRule) ||\n            (hasNestedCSSRule('CSSConditionRule') &&\n                childRule.parentRule instanceof CSSConditionRule)) {\n            const rules = Array.from(childRule.parentRule.cssRules);\n            const index = rules.indexOf(childRule);\n            pos.unshift(index);\n        }\n        else if (childRule.parentStyleSheet) {\n            const rules = Array.from(childRule.parentStyleSheet.cssRules);\n            const index = rules.indexOf(childRule);\n            pos.unshift(index);\n        }\n        return pos;\n    }\n    return recurse(rule, positions);\n}\nfunction getIdAndStyleId(sheet, mirror, styleMirror) {\n    let id, styleId;\n    if (!sheet)\n        return {};\n    if (sheet.ownerNode)\n        id = mirror.getId(sheet.ownerNode);\n    else\n        styleId = styleMirror.getId(sheet);\n    return {\n        styleId,\n        id,\n    };\n}\nfunction initStyleSheetObserver({ styleSheetRuleCb, mirror, stylesheetManager }, { win }) {\n    if (!win.CSSStyleSheet || !win.CSSStyleSheet.prototype) {\n        return () => {\n        };\n    }\n    const insertRule = win.CSSStyleSheet.prototype.insertRule;\n    win.CSSStyleSheet.prototype.insertRule = new Proxy(insertRule, {\n        apply: callbackWrapper((target, thisArg, argumentsList) => {\n            const [rule, index] = argumentsList;\n            const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\n            if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                styleSheetRuleCb({\n                    id,\n                    styleId,\n                    adds: [{ rule, index }],\n                });\n            }\n            return target.apply(thisArg, argumentsList);\n        }),\n    });\n    const deleteRule = win.CSSStyleSheet.prototype.deleteRule;\n    win.CSSStyleSheet.prototype.deleteRule = new Proxy(deleteRule, {\n        apply: callbackWrapper((target, thisArg, argumentsList) => {\n            const [index] = argumentsList;\n            const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\n            if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                styleSheetRuleCb({\n                    id,\n                    styleId,\n                    removes: [{ index }],\n                });\n            }\n            return target.apply(thisArg, argumentsList);\n        }),\n    });\n    let replace;\n    if (win.CSSStyleSheet.prototype.replace) {\n        replace = win.CSSStyleSheet.prototype.replace;\n        win.CSSStyleSheet.prototype.replace = new Proxy(replace, {\n            apply: callbackWrapper((target, thisArg, argumentsList) => {\n                const [text] = argumentsList;\n                const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\n                if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                    styleSheetRuleCb({\n                        id,\n                        styleId,\n                        replace: text,\n                    });\n                }\n                return target.apply(thisArg, argumentsList);\n            }),\n        });\n    }\n    let replaceSync;\n    if (win.CSSStyleSheet.prototype.replaceSync) {\n        replaceSync = win.CSSStyleSheet.prototype.replaceSync;\n        win.CSSStyleSheet.prototype.replaceSync = new Proxy(replaceSync, {\n            apply: callbackWrapper((target, thisArg, argumentsList) => {\n                const [text] = argumentsList;\n                const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\n                if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                    styleSheetRuleCb({\n                        id,\n                        styleId,\n                        replaceSync: text,\n                    });\n                }\n                return target.apply(thisArg, argumentsList);\n            }),\n        });\n    }\n    const supportedNestedCSSRuleTypes = {};\n    if (canMonkeyPatchNestedCSSRule('CSSGroupingRule')) {\n        supportedNestedCSSRuleTypes.CSSGroupingRule = win.CSSGroupingRule;\n    }\n    else {\n        if (canMonkeyPatchNestedCSSRule('CSSMediaRule')) {\n            supportedNestedCSSRuleTypes.CSSMediaRule = win.CSSMediaRule;\n        }\n        if (canMonkeyPatchNestedCSSRule('CSSConditionRule')) {\n            supportedNestedCSSRuleTypes.CSSConditionRule = win.CSSConditionRule;\n        }\n        if (canMonkeyPatchNestedCSSRule('CSSSupportsRule')) {\n            supportedNestedCSSRuleTypes.CSSSupportsRule = win.CSSSupportsRule;\n        }\n    }\n    const unmodifiedFunctions = {};\n    Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {\n        unmodifiedFunctions[typeKey] = {\n            insertRule: type.prototype.insertRule,\n            deleteRule: type.prototype.deleteRule,\n        };\n        type.prototype.insertRule = new Proxy(unmodifiedFunctions[typeKey].insertRule, {\n            apply: callbackWrapper((target, thisArg, argumentsList) => {\n                const [rule, index] = argumentsList;\n                const { id, styleId } = getIdAndStyleId(thisArg.parentStyleSheet, mirror, stylesheetManager.styleMirror);\n                if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                    styleSheetRuleCb({\n                        id,\n                        styleId,\n                        adds: [\n                            {\n                                rule,\n                                index: [\n                                    ...getNestedCSSRulePositions(thisArg),\n                                    index || 0,\n                                ],\n                            },\n                        ],\n                    });\n                }\n                return target.apply(thisArg, argumentsList);\n            }),\n        });\n        type.prototype.deleteRule = new Proxy(unmodifiedFunctions[typeKey].deleteRule, {\n            apply: callbackWrapper((target, thisArg, argumentsList) => {\n                const [index] = argumentsList;\n                const { id, styleId } = getIdAndStyleId(thisArg.parentStyleSheet, mirror, stylesheetManager.styleMirror);\n                if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                    styleSheetRuleCb({\n                        id,\n                        styleId,\n                        removes: [\n                            { index: [...getNestedCSSRulePositions(thisArg), index] },\n                        ],\n                    });\n                }\n                return target.apply(thisArg, argumentsList);\n            }),\n        });\n    });\n    return callbackWrapper(() => {\n        win.CSSStyleSheet.prototype.insertRule = insertRule;\n        win.CSSStyleSheet.prototype.deleteRule = deleteRule;\n        replace && (win.CSSStyleSheet.prototype.replace = replace);\n        replaceSync && (win.CSSStyleSheet.prototype.replaceSync = replaceSync);\n        Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {\n            type.prototype.insertRule = unmodifiedFunctions[typeKey].insertRule;\n            type.prototype.deleteRule = unmodifiedFunctions[typeKey].deleteRule;\n        });\n    });\n}\nfunction initAdoptedStyleSheetObserver({ mirror, stylesheetManager, }, host) {\n    let hostId = null;\n    if (host.nodeName === '#document')\n        hostId = mirror.getId(host);\n    else\n        hostId = mirror.getId(host.host);\n    const patchTarget = host.nodeName === '#document'\n        ? host.defaultView?.Document\n        : host.ownerDocument?.defaultView?.ShadowRoot;\n    const originalPropertyDescriptor = patchTarget?.prototype\n        ? Object.getOwnPropertyDescriptor(patchTarget?.prototype, 'adoptedStyleSheets')\n        : undefined;\n    if (hostId === null ||\n        hostId === -1 ||\n        !patchTarget ||\n        !originalPropertyDescriptor)\n        return () => {\n        };\n    Object.defineProperty(host, 'adoptedStyleSheets', {\n        configurable: originalPropertyDescriptor.configurable,\n        enumerable: originalPropertyDescriptor.enumerable,\n        get() {\n            return 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                }\n                catch (e) {\n                }\n            }\n            return result;\n        },\n    });\n    return callbackWrapper(() => {\n        Object.defineProperty(host, 'adoptedStyleSheets', {\n            configurable: originalPropertyDescriptor.configurable,\n            enumerable: originalPropertyDescriptor.enumerable,\n            get: originalPropertyDescriptor.get,\n            set: originalPropertyDescriptor.set,\n        });\n    });\n}\nfunction initStyleDeclarationObserver({ styleDeclarationCb, mirror, ignoreCSSAttributes, stylesheetManager, }, { win }) {\n    const setProperty = win.CSSStyleDeclaration.prototype.setProperty;\n    win.CSSStyleDeclaration.prototype.setProperty = new Proxy(setProperty, {\n        apply: callbackWrapper((target, thisArg, argumentsList) => {\n            const [property, value, priority] = argumentsList;\n            if (ignoreCSSAttributes.has(property)) {\n                return setProperty.apply(thisArg, [property, value, priority]);\n            }\n            const { id, styleId } = getIdAndStyleId(thisArg.parentRule?.parentStyleSheet, mirror, stylesheetManager.styleMirror);\n            if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                styleDeclarationCb({\n                    id,\n                    styleId,\n                    set: {\n                        property,\n                        value,\n                        priority,\n                    },\n                    index: getNestedCSSRulePositions(thisArg.parentRule),\n                });\n            }\n            return target.apply(thisArg, argumentsList);\n        }),\n    });\n    const removeProperty = win.CSSStyleDeclaration.prototype.removeProperty;\n    win.CSSStyleDeclaration.prototype.removeProperty = new Proxy(removeProperty, {\n        apply: callbackWrapper((target, thisArg, argumentsList) => {\n            const [property] = argumentsList;\n            if (ignoreCSSAttributes.has(property)) {\n                return removeProperty.apply(thisArg, [property]);\n            }\n            const { id, styleId } = getIdAndStyleId(thisArg.parentRule?.parentStyleSheet, mirror, stylesheetManager.styleMirror);\n            if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                styleDeclarationCb({\n                    id,\n                    styleId,\n                    remove: {\n                        property,\n                    },\n                    index: getNestedCSSRulePositions(thisArg.parentRule),\n                });\n            }\n            return target.apply(thisArg, argumentsList);\n        }),\n    });\n    return callbackWrapper(() => {\n        win.CSSStyleDeclaration.prototype.setProperty = setProperty;\n        win.CSSStyleDeclaration.prototype.removeProperty = removeProperty;\n    });\n}\nfunction initMediaInteractionObserver({ mediaInteractionCb, blockClass, blockSelector, unblockSelector, mirror, sampling, doc, }) {\n    const handler = callbackWrapper((type) => throttle$1(callbackWrapper((event) => {\n        const target = getEventTarget(event);\n        if (!target ||\n            isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\n            return;\n        }\n        const { currentTime, volume, muted, playbackRate } = target;\n        mediaInteractionCb({\n            type,\n            id: mirror.getId(target),\n            currentTime,\n            volume,\n            muted,\n            playbackRate,\n        });\n    }), sampling.media || 500));\n    const handlers = [\n        on('play', handler(0), doc),\n        on('pause', handler(1), doc),\n        on('seeked', handler(2), doc),\n        on('volumechange', handler(3), doc),\n        on('ratechange', handler(4), doc),\n    ];\n    return callbackWrapper(() => {\n        handlers.forEach((h) => h());\n    });\n}\nfunction initFontObserver({ fontCb, doc }) {\n    const win = doc.defaultView;\n    if (!win) {\n        return () => {\n        };\n    }\n    const handlers = [];\n    const fontMap = new WeakMap();\n    const originalFontFace = win.FontFace;\n    win.FontFace = function FontFace(family, source, descriptors) {\n        const fontFace = new originalFontFace(family, source, descriptors);\n        fontMap.set(fontFace, {\n            family,\n            buffer: typeof source !== 'string',\n            descriptors,\n            fontSource: typeof source === 'string'\n                ? source\n                : JSON.stringify(Array.from(new Uint8Array(source))),\n        });\n        return fontFace;\n    };\n    const restoreHandler = patch(doc.fonts, 'add', function (original) {\n        return function (fontFace) {\n            setTimeout$1(callbackWrapper(() => {\n                const p = fontMap.get(fontFace);\n                if (p) {\n                    fontCb(p);\n                    fontMap.delete(fontFace);\n                }\n            }), 0);\n            return original.apply(this, [fontFace]);\n        };\n    });\n    handlers.push(() => {\n        win.FontFace = originalFontFace;\n    });\n    handlers.push(restoreHandler);\n    return callbackWrapper(() => {\n        handlers.forEach((h) => h());\n    });\n}\nfunction initSelectionObserver(param) {\n    const { doc, mirror, blockClass, blockSelector, unblockSelector, selectionCb, } = param;\n    let collapsed = true;\n    const updateSelection = callbackWrapper(() => {\n        const selection = doc.getSelection();\n        if (!selection || (collapsed && selection?.isCollapsed))\n            return;\n        collapsed = selection.isCollapsed || false;\n        const ranges = [];\n        const count = selection.rangeCount || 0;\n        for (let i = 0; i < count; i++) {\n            const range = selection.getRangeAt(i);\n            const { startContainer, startOffset, endContainer, endOffset } = range;\n            const blocked = isBlocked(startContainer, blockClass, blockSelector, unblockSelector, true) ||\n                isBlocked(endContainer, blockClass, blockSelector, unblockSelector, true);\n            if (blocked)\n                continue;\n            ranges.push({\n                start: mirror.getId(startContainer),\n                startOffset,\n                end: mirror.getId(endContainer),\n                endOffset,\n            });\n        }\n        selectionCb({ ranges });\n    });\n    updateSelection();\n    return on('selectionchange', updateSelection);\n}\nfunction initCustomElementObserver({ doc, customElementCb, }) {\n    const win = doc.defaultView;\n    if (!win || !win.customElements)\n        return () => { };\n    const restoreHandler = patch(win.customElements, 'define', function (original) {\n        return function (name, constructor, options) {\n            try {\n                customElementCb({\n                    define: {\n                        name,\n                    },\n                });\n            }\n            catch (e) {\n            }\n            return original.apply(this, [name, constructor, options]);\n        };\n    });\n    return restoreHandler;\n}\nfunction initObservers(o, _hooks = {}) {\n    const currentWindow = o.doc.defaultView;\n    if (!currentWindow) {\n        return () => {\n        };\n    }\n    let mutationObserver;\n    if (o.recordDOM) {\n        mutationObserver = initMutationObserver(o, o.doc);\n    }\n    const mousemoveHandler = initMoveObserver(o);\n    const mouseInteractionHandler = initMouseInteractionObserver(o);\n    const scrollHandler = initScrollObserver(o);\n    const viewportResizeHandler = initViewportResizeObserver(o, {\n        win: currentWindow,\n    });\n    const inputHandler = initInputObserver(o);\n    const mediaInteractionHandler = initMediaInteractionObserver(o);\n    let styleSheetObserver = () => { };\n    let adoptedStyleSheetObserver = () => { };\n    let styleDeclarationObserver = () => { };\n    let fontObserver = () => { };\n    if (o.recordDOM) {\n        styleSheetObserver = initStyleSheetObserver(o, { win: currentWindow });\n        adoptedStyleSheetObserver = initAdoptedStyleSheetObserver(o, o.doc);\n        styleDeclarationObserver = initStyleDeclarationObserver(o, {\n            win: currentWindow,\n        });\n        if (o.collectFonts) {\n            fontObserver = initFontObserver(o);\n        }\n    }\n    const selectionObserver = initSelectionObserver(o);\n    const customElementObserver = initCustomElementObserver(o);\n    const pluginHandlers = [];\n    for (const plugin of o.plugins) {\n        pluginHandlers.push(plugin.observer(plugin.callback, currentWindow, plugin.options));\n    }\n    return callbackWrapper(() => {\n        mutationBuffers.forEach((b) => b.reset());\n        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(typeof window[prop] !== 'undefined' &&\n        window[prop].prototype &&\n        'insertRule' in window[prop].prototype &&\n        'deleteRule' in window[prop].prototype);\n}\n\nclass CrossOriginIframeMirror {\n    constructor(generateIdFn) {\n        this.generateIdFn = generateIdFn;\n        this.iframeIdToRemoteIdMap = new WeakMap();\n        this.iframeRemoteIdToIdMap = new WeakMap();\n    }\n    getId(iframe, remoteId, idToRemoteMap, remoteToIdMap) {\n        const idToRemoteIdMap = idToRemoteMap || this.getIdToRemoteIdMap(iframe);\n        const remoteIdToIdMap = remoteToIdMap || this.getRemoteIdToIdMap(iframe);\n        let id = idToRemoteIdMap.get(remoteId);\n        if (!id) {\n            id = this.generateIdFn();\n            idToRemoteIdMap.set(remoteId, id);\n            remoteIdToIdMap.set(id, remoteId);\n        }\n        return id;\n    }\n    getIds(iframe, remoteId) {\n        const idToRemoteIdMap = this.getIdToRemoteIdMap(iframe);\n        const remoteIdToIdMap = this.getRemoteIdToIdMap(iframe);\n        return remoteId.map((id) => this.getId(iframe, id, idToRemoteIdMap, remoteIdToIdMap));\n    }\n    getRemoteId(iframe, id, map) {\n        const remoteIdToIdMap = map || this.getRemoteIdToIdMap(iframe);\n        if (typeof id !== 'number')\n            return id;\n        const remoteId = remoteIdToIdMap.get(id);\n        if (!remoteId)\n            return -1;\n        return remoteId;\n    }\n    getRemoteIds(iframe, ids) {\n        const remoteIdToIdMap = this.getRemoteIdToIdMap(iframe);\n        return ids.map((id) => this.getRemoteId(iframe, id, remoteIdToIdMap));\n    }\n    reset(iframe) {\n        if (!iframe) {\n            this.iframeIdToRemoteIdMap = new WeakMap();\n            this.iframeRemoteIdToIdMap = new WeakMap();\n            return;\n        }\n        this.iframeIdToRemoteIdMap.delete(iframe);\n        this.iframeRemoteIdToIdMap.delete(iframe);\n    }\n    getIdToRemoteIdMap(iframe) {\n        let idToRemoteIdMap = this.iframeIdToRemoteIdMap.get(iframe);\n        if (!idToRemoteIdMap) {\n            idToRemoteIdMap = new Map();\n            this.iframeIdToRemoteIdMap.set(iframe, idToRemoteIdMap);\n        }\n        return idToRemoteIdMap;\n    }\n    getRemoteIdToIdMap(iframe) {\n        let remoteIdToIdMap = this.iframeRemoteIdToIdMap.get(iframe);\n        if (!remoteIdToIdMap) {\n            remoteIdToIdMap = new Map();\n            this.iframeRemoteIdToIdMap.set(iframe, remoteIdToIdMap);\n        }\n        return remoteIdToIdMap;\n    }\n}\n\nclass IframeManagerNoop {\n    constructor() {\n        this.crossOriginIframeMirror = new CrossOriginIframeMirror(genId);\n        this.crossOriginIframeRootIdMap = new WeakMap();\n    }\n    addIframe() {\n    }\n    addLoadListener() {\n    }\n    attachIframe() {\n    }\n}\nclass IframeManager {\n    constructor(options) {\n        this.iframes = new WeakMap();\n        this.crossOriginIframeMap = new WeakMap();\n        this.crossOriginIframeMirror = new CrossOriginIframeMirror(genId);\n        this.crossOriginIframeRootIdMap = new WeakMap();\n        this.mutationCb = options.mutationCb;\n        this.wrappedEmit = options.wrappedEmit;\n        this.stylesheetManager = options.stylesheetManager;\n        this.recordCrossOriginIframes = options.recordCrossOriginIframes;\n        this.crossOriginIframeStyleMirror = new CrossOriginIframeMirror(this.stylesheetManager.styleMirror.generateId.bind(this.stylesheetManager.styleMirror));\n        this.mirror = options.mirror;\n        if (this.recordCrossOriginIframes) {\n            window.addEventListener('message', this.handleMessage.bind(this));\n        }\n    }\n    addIframe(iframeEl) {\n        this.iframes.set(iframeEl, true);\n        if (iframeEl.contentWindow)\n            this.crossOriginIframeMap.set(iframeEl.contentWindow, iframeEl);\n    }\n    addLoadListener(cb) {\n        this.loadListener = cb;\n    }\n    attachIframe(iframeEl, childSn) {\n        this.mutationCb({\n            adds: [\n                {\n                    parentId: this.mirror.getId(iframeEl),\n                    nextId: null,\n                    node: childSn,\n                },\n            ],\n            removes: [],\n            texts: [],\n            attributes: [],\n            isAttachIframe: true,\n        });\n        this.loadListener?.(iframeEl);\n        const iframeDoc = getIFrameContentDocument(iframeEl);\n        if (iframeDoc &&\n            iframeDoc.adoptedStyleSheets &&\n            iframeDoc.adoptedStyleSheets.length > 0)\n            this.stylesheetManager.adoptStyleSheets(iframeDoc.adoptedStyleSheets, this.mirror.getId(iframeDoc));\n    }\n    handleMessage(message) {\n        const crossOriginMessageEvent = message;\n        if (crossOriginMessageEvent.data.type !== 'rrweb' ||\n            crossOriginMessageEvent.origin !== crossOriginMessageEvent.data.origin)\n            return;\n        const iframeSourceWindow = message.source;\n        if (!iframeSourceWindow)\n            return;\n        const iframeEl = this.crossOriginIframeMap.get(message.source);\n        if (!iframeEl)\n            return;\n        const transformedEvent = this.transformCrossOriginEvent(iframeEl, crossOriginMessageEvent.data.event);\n        if (transformedEvent)\n            this.wrappedEmit(transformedEvent, crossOriginMessageEvent.data.isCheckout);\n    }\n    transformCrossOriginEvent(iframeEl, e) {\n        switch (e.type) {\n            case EventType.FullSnapshot: {\n                this.crossOriginIframeMirror.reset(iframeEl);\n                this.crossOriginIframeStyleMirror.reset(iframeEl);\n                this.replaceIdOnNode(e.data.node, iframeEl);\n                const rootId = e.data.node.id;\n                this.crossOriginIframeRootIdMap.set(iframeEl, rootId);\n                this.patchRootIdOnNode(e.data.node, rootId);\n                return {\n                    timestamp: e.timestamp,\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.Mutation,\n                        adds: [\n                            {\n                                parentId: this.mirror.getId(iframeEl),\n                                nextId: null,\n                                node: e.data.node,\n                            },\n                        ],\n                        removes: [],\n                        texts: [],\n                        attributes: [],\n                        isAttachIframe: true,\n                    },\n                };\n            }\n            case EventType.Meta:\n            case EventType.Load:\n            case EventType.DomContentLoaded: {\n                return false;\n            }\n            case EventType.Plugin: {\n                return e;\n            }\n            case EventType.Custom: {\n                this.replaceIds(e.data.payload, iframeEl, ['id', 'parentId', 'previousId', 'nextId']);\n                return e;\n            }\n            case EventType.IncrementalSnapshot: {\n                switch (e.data.source) {\n                    case IncrementalSource.Mutation: {\n                        e.data.adds.forEach((n) => {\n                            this.replaceIds(n, iframeEl, [\n                                'parentId',\n                                'nextId',\n                                'previousId',\n                            ]);\n                            this.replaceIdOnNode(n.node, iframeEl);\n                            const rootId = this.crossOriginIframeRootIdMap.get(iframeEl);\n                            rootId && this.patchRootIdOnNode(n.node, rootId);\n                        });\n                        e.data.removes.forEach((n) => {\n                            this.replaceIds(n, iframeEl, ['parentId', 'id']);\n                        });\n                        e.data.attributes.forEach((n) => {\n                            this.replaceIds(n, iframeEl, ['id']);\n                        });\n                        e.data.texts.forEach((n) => {\n                            this.replaceIds(n, iframeEl, ['id']);\n                        });\n                        return e;\n                    }\n                    case IncrementalSource.Drag:\n                    case IncrementalSource.TouchMove:\n                    case IncrementalSource.MouseMove: {\n                        e.data.positions.forEach((p) => {\n                            this.replaceIds(p, iframeEl, ['id']);\n                        });\n                        return e;\n                    }\n                    case IncrementalSource.ViewportResize: {\n                        return false;\n                    }\n                    case IncrementalSource.MediaInteraction:\n                    case IncrementalSource.MouseInteraction:\n                    case IncrementalSource.Scroll:\n                    case IncrementalSource.CanvasMutation:\n                    case IncrementalSource.Input: {\n                        this.replaceIds(e.data, iframeEl, ['id']);\n                        return e;\n                    }\n                    case IncrementalSource.StyleSheetRule:\n                    case IncrementalSource.StyleDeclaration: {\n                        this.replaceIds(e.data, iframeEl, ['id']);\n                        this.replaceStyleIds(e.data, iframeEl, ['styleId']);\n                        return e;\n                    }\n                    case IncrementalSource.Font: {\n                        return e;\n                    }\n                    case IncrementalSource.Selection: {\n                        e.data.ranges.forEach((range) => {\n                            this.replaceIds(range, iframeEl, ['start', 'end']);\n                        });\n                        return e;\n                    }\n                    case IncrementalSource.AdoptedStyleSheet: {\n                        this.replaceIds(e.data, iframeEl, ['id']);\n                        this.replaceStyleIds(e.data, iframeEl, ['styleIds']);\n                        e.data.styles?.forEach((style) => {\n                            this.replaceStyleIds(style, iframeEl, ['styleId']);\n                        });\n                        return e;\n                    }\n                }\n            }\n        }\n        return false;\n    }\n    replace(iframeMirror, obj, iframeEl, keys) {\n        for (const key of keys) {\n            if (!Array.isArray(obj[key]) && typeof obj[key] !== 'number')\n                continue;\n            if (Array.isArray(obj[key])) {\n                obj[key] = iframeMirror.getIds(iframeEl, obj[key]);\n            }\n            else {\n                obj[key] = iframeMirror.getId(iframeEl, obj[key]);\n            }\n        }\n        return obj;\n    }\n    replaceIds(obj, iframeEl, keys) {\n        return this.replace(this.crossOriginIframeMirror, obj, iframeEl, keys);\n    }\n    replaceStyleIds(obj, iframeEl, keys) {\n        return this.replace(this.crossOriginIframeStyleMirror, obj, iframeEl, keys);\n    }\n    replaceIdOnNode(node, iframeEl) {\n        this.replaceIds(node, iframeEl, ['id', 'rootId']);\n        if ('childNodes' in node) {\n            node.childNodes.forEach((child) => {\n                this.replaceIdOnNode(child, iframeEl);\n            });\n        }\n    }\n    patchRootIdOnNode(node, rootId) {\n        if (node.type !== NodeType$3.Document && !node.rootId)\n            node.rootId = rootId;\n        if ('childNodes' in node) {\n            node.childNodes.forEach((child) => {\n                this.patchRootIdOnNode(child, rootId);\n            });\n        }\n    }\n}\n\nclass ShadowDomManagerNoop {\n    init() {\n    }\n    addShadowRoot() {\n    }\n    observeAttachShadow() {\n    }\n    reset() {\n    }\n}\nclass ShadowDomManager {\n    constructor(options) {\n        this.shadowDoms = new WeakSet();\n        this.restoreHandlers = [];\n        this.mutationCb = options.mutationCb;\n        this.scrollCb = options.scrollCb;\n        this.bypassOptions = options.bypassOptions;\n        this.mirror = options.mirror;\n        this.init();\n    }\n    init() {\n        this.reset();\n        this.patchAttachShadow(Element, document);\n    }\n    addShadowRoot(shadowRoot, doc) {\n        if (!isNativeShadowDom(shadowRoot))\n            return;\n        if (this.shadowDoms.has(shadowRoot))\n            return;\n        this.shadowDoms.add(shadowRoot);\n        this.bypassOptions.canvasManager.addShadowRoot(shadowRoot);\n        const observer = initMutationObserver({\n            ...this.bypassOptions,\n            doc,\n            mutationCb: this.mutationCb,\n            mirror: this.mirror,\n            shadowDomManager: this,\n        }, shadowRoot);\n        this.restoreHandlers.push(() => observer.disconnect());\n        this.restoreHandlers.push(initScrollObserver({\n            ...this.bypassOptions,\n            scrollCb: this.scrollCb,\n            doc: shadowRoot,\n            mirror: this.mirror,\n        }));\n        setTimeout$1(() => {\n            if (shadowRoot.adoptedStyleSheets &&\n                shadowRoot.adoptedStyleSheets.length > 0)\n                this.bypassOptions.stylesheetManager.adoptStyleSheets(shadowRoot.adoptedStyleSheets, this.mirror.getId(shadowRoot.host));\n            this.restoreHandlers.push(initAdoptedStyleSheetObserver({\n                mirror: this.mirror,\n                stylesheetManager: this.bypassOptions.stylesheetManager,\n            }, shadowRoot));\n        }, 0);\n    }\n    observeAttachShadow(iframeElement) {\n        const iframeDoc = getIFrameContentDocument(iframeElement);\n        const iframeWindow = getIFrameContentWindow(iframeElement);\n        if (!iframeDoc || !iframeWindow)\n            return;\n        this.patchAttachShadow(iframeWindow.Element, iframeDoc);\n    }\n    patchAttachShadow(element, doc) {\n        const manager = this;\n        this.restoreHandlers.push(patch(element.prototype, 'attachShadow', function (original) {\n            return function (option) {\n                const shadowRoot = original.call(this, option);\n                if (this.shadowRoot && inDom(this))\n                    manager.addShadowRoot(this.shadowRoot, doc);\n                return shadowRoot;\n            };\n        }));\n    }\n    reset() {\n        this.restoreHandlers.forEach((handler) => {\n            try {\n                handler();\n            }\n            catch (e) {\n            }\n        });\n        this.restoreHandlers = [];\n        this.shadowDoms = new WeakSet();\n        this.bypassOptions.canvasManager.resetShadowRoots();\n    }\n}\n\nclass CanvasManagerNoop {\n    reset() {\n    }\n    freeze() {\n    }\n    unfreeze() {\n    }\n    lock() {\n    }\n    unlock() {\n    }\n    snapshot() {\n    }\n    addWindow() {\n    }\n    addShadowRoot() {\n    }\n    resetShadowRoots() {\n    }\n}\n\nclass StylesheetManager {\n    constructor(options) {\n        this.trackedLinkElements = new WeakSet();\n        this.styleMirror = new StyleSheetMirror();\n        this.mutationCb = options.mutationCb;\n        this.adoptedStyleSheetCb = options.adoptedStyleSheetCb;\n    }\n    attachLinkElement(linkEl, childSn) {\n        if ('_cssText' in childSn.attributes)\n            this.mutationCb({\n                adds: [],\n                removes: [],\n                texts: [],\n                attributes: [\n                    {\n                        id: childSn.id,\n                        attributes: childSn\n                            .attributes,\n                    },\n                ],\n            });\n        this.trackLinkElement(linkEl);\n    }\n    trackLinkElement(linkEl) {\n        if (this.trackedLinkElements.has(linkEl))\n            return;\n        this.trackedLinkElements.add(linkEl);\n        this.trackStylesheetInLinkElement(linkEl);\n    }\n    adoptStyleSheets(sheets, hostId) {\n        if (sheets.length === 0)\n            return;\n        const adoptedStyleSheetData = {\n            id: hostId,\n            styleIds: [],\n        };\n        const styles = [];\n        for (const sheet of sheets) {\n            let styleId;\n            if (!this.styleMirror.has(sheet)) {\n                styleId = this.styleMirror.add(sheet);\n                styles.push({\n                    styleId,\n                    rules: Array.from(sheet.rules || CSSRule, (r, index) => ({\n                        rule: stringifyRule(r),\n                        index,\n                    })),\n                });\n            }\n            else\n                styleId = this.styleMirror.getId(sheet);\n            adoptedStyleSheetData.styleIds.push(styleId);\n        }\n        if (styles.length > 0)\n            adoptedStyleSheetData.styles = styles;\n        this.adoptedStyleSheetCb(adoptedStyleSheetData);\n    }\n    reset() {\n        this.styleMirror.reset();\n        this.trackedLinkElements = new WeakSet();\n    }\n    trackStylesheetInLinkElement(linkEl) {\n    }\n}\n\nclass ProcessedNodeManager {\n    constructor() {\n        this.nodeMap = new WeakMap();\n        this.active = false;\n    }\n    inOtherBuffer(node, thisBuffer) {\n        const buffers = this.nodeMap.get(node);\n        return (buffers && Array.from(buffers).some((buffer) => buffer !== thisBuffer));\n    }\n    add(node, buffer) {\n        if (!this.active) {\n            this.active = true;\n            onRequestAnimationFrame(() => {\n                this.nodeMap = new WeakMap();\n                this.active = false;\n            });\n        }\n        this.nodeMap.set(node, (this.nodeMap.get(node) || new Set()).add(buffer));\n    }\n    destroy() {\n    }\n}\n\nlet wrappedEmit;\nlet _takeFullSnapshot;\ntry {\n    if (Array.from([1], (x) => x * 2)[0] !== 2) {\n        const cleanFrame = document.createElement('iframe');\n        document.body.appendChild(cleanFrame);\n        Array.from = cleanFrame.contentWindow?.Array.from || Array.from;\n        document.body.removeChild(cleanFrame);\n    }\n}\ncatch (err) {\n    console.debug('Unable to override Array.from', err);\n}\nconst mirror = createMirror();\nfunction record(options = {}) {\n    const { emit, checkoutEveryNms, checkoutEveryNth, blockClass = 'rr-block', blockSelector = null, unblockSelector = null, ignoreClass = 'rr-ignore', ignoreSelector = null, maskAllText = false, maskTextClass = 'rr-mask', unmaskTextClass = null, maskTextSelector = null, unmaskTextSelector = null, inlineStylesheet = true, maskAllInputs, maskInputOptions: _maskInputOptions, slimDOMOptions: _slimDOMOptions, maskAttributeFn, maskInputFn, maskTextFn, maxCanvasSize = null, packFn, sampling = {}, dataURLOptions = {}, mousemoveWait, recordDOM = true, recordCanvas = false, recordCrossOriginIframes = false, recordAfter = options.recordAfter === 'DOMContentLoaded'\n        ? options.recordAfter\n        : 'load', userTriggeredOnInput = false, collectFonts = false, inlineImages = false, plugins, keepIframeSrcFn = () => false, ignoreCSSAttributes = new Set([]), errorHandler, onMutation, getCanvasManager, } = options;\n    registerErrorHandler(errorHandler);\n    const inEmittingFrame = recordCrossOriginIframes\n        ? window.parent === window\n        : true;\n    let passEmitsToParent = false;\n    if (!inEmittingFrame) {\n        try {\n            if (window.parent.document) {\n                passEmitsToParent = false;\n            }\n        }\n        catch (e) {\n            passEmitsToParent = true;\n        }\n    }\n    if (inEmittingFrame && !emit) {\n        throw new Error('emit function is required');\n    }\n    if (!inEmittingFrame && !passEmitsToParent) {\n        return () => {\n        };\n    }\n    if (mousemoveWait !== undefined && sampling.mousemove === undefined) {\n        sampling.mousemove = mousemoveWait;\n    }\n    mirror.reset();\n    const maskInputOptions = maskAllInputs === true\n        ? {\n            color: true,\n            date: true,\n            'datetime-local': true,\n            email: true,\n            month: true,\n            number: true,\n            range: true,\n            search: true,\n            tel: true,\n            text: true,\n            time: true,\n            url: true,\n            week: true,\n            textarea: true,\n            select: true,\n            radio: true,\n            checkbox: true,\n        }\n        : _maskInputOptions !== undefined\n            ? _maskInputOptions\n            : {};\n    const slimDOMOptions = _slimDOMOptions === true || _slimDOMOptions === 'all'\n        ? {\n            script: true,\n            comment: true,\n            headFavicon: true,\n            headWhitespace: true,\n            headMetaSocial: true,\n            headMetaRobots: true,\n            headMetaHttpEquiv: true,\n            headMetaVerification: true,\n            headMetaAuthorship: _slimDOMOptions === 'all',\n            headMetaDescKeywords: _slimDOMOptions === 'all',\n        }\n        : _slimDOMOptions\n            ? _slimDOMOptions\n            : {};\n    polyfill();\n    let lastFullSnapshotEvent;\n    let incrementalSnapshotCount = 0;\n    const eventProcessor = (e) => {\n        for (const plugin of plugins || []) {\n            if (plugin.eventProcessor) {\n                e = plugin.eventProcessor(e);\n            }\n        }\n        if (packFn &&\n            !passEmitsToParent) {\n            e = packFn(e);\n        }\n        return e;\n    };\n    wrappedEmit = (r, isCheckout) => {\n        const e = r;\n        e.timestamp = nowTimestamp();\n        if (mutationBuffers[0]?.isFrozen() &&\n            e.type !== EventType.FullSnapshot &&\n            !(e.type === EventType.IncrementalSnapshot &&\n                e.data.source === IncrementalSource.Mutation)) {\n            mutationBuffers.forEach((buf) => buf.unfreeze());\n        }\n        if (inEmittingFrame) {\n            emit?.(eventProcessor(e), isCheckout);\n        }\n        else if (passEmitsToParent) {\n            const message = {\n                type: 'rrweb',\n                event: eventProcessor(e),\n                origin: window.location.origin,\n                isCheckout,\n            };\n            window.parent.postMessage(message, '*');\n        }\n        if (e.type === EventType.FullSnapshot) {\n            lastFullSnapshotEvent = e;\n            incrementalSnapshotCount = 0;\n        }\n        else if (e.type === EventType.IncrementalSnapshot) {\n            if (e.data.source === IncrementalSource.Mutation &&\n                e.data.isAttachIframe) {\n                return;\n            }\n            incrementalSnapshotCount++;\n            const exceedCount = checkoutEveryNth && incrementalSnapshotCount >= checkoutEveryNth;\n            const exceedTime = checkoutEveryNms &&\n                lastFullSnapshotEvent &&\n                e.timestamp - lastFullSnapshotEvent.timestamp > checkoutEveryNms;\n            if (exceedCount || exceedTime) {\n                takeFullSnapshot(true);\n            }\n        }\n    };\n    const wrappedMutationEmit = (m) => {\n        wrappedEmit({\n            type: EventType.IncrementalSnapshot,\n            data: {\n                source: IncrementalSource.Mutation,\n                ...m,\n            },\n        });\n    };\n    const wrappedScrollEmit = (p) => wrappedEmit({\n        type: EventType.IncrementalSnapshot,\n        data: {\n            source: IncrementalSource.Scroll,\n            ...p,\n        },\n    });\n    const wrappedCanvasMutationEmit = (p) => wrappedEmit({\n        type: EventType.IncrementalSnapshot,\n        data: {\n            source: IncrementalSource.CanvasMutation,\n            ...p,\n        },\n    });\n    const wrappedAdoptedStyleSheetEmit = (a) => wrappedEmit({\n        type: EventType.IncrementalSnapshot,\n        data: {\n            source: IncrementalSource.AdoptedStyleSheet,\n            ...a,\n        },\n    });\n    const stylesheetManager = new StylesheetManager({\n        mutationCb: wrappedMutationEmit,\n        adoptedStyleSheetCb: wrappedAdoptedStyleSheetEmit,\n    });\n    const iframeManager = typeof __RRWEB_EXCLUDE_IFRAME__ === 'boolean' && __RRWEB_EXCLUDE_IFRAME__\n        ? new IframeManagerNoop()\n        : new IframeManager({\n            mirror,\n            mutationCb: wrappedMutationEmit,\n            stylesheetManager: stylesheetManager,\n            recordCrossOriginIframes,\n            wrappedEmit,\n        });\n    for (const plugin of plugins || []) {\n        if (plugin.getMirror)\n            plugin.getMirror({\n                nodeMirror: mirror,\n                crossOriginIframeMirror: iframeManager.crossOriginIframeMirror,\n                crossOriginIframeStyleMirror: iframeManager.crossOriginIframeStyleMirror,\n            });\n    }\n    const processedNodeManager = new ProcessedNodeManager();\n    const canvasManager = _getCanvasManager(getCanvasManager, {\n        mirror,\n        win: window,\n        mutationCb: (p) => wrappedEmit({\n            type: EventType.IncrementalSnapshot,\n            data: {\n                source: IncrementalSource.CanvasMutation,\n                ...p,\n            },\n        }),\n        recordCanvas,\n        blockClass,\n        blockSelector,\n        unblockSelector,\n        maxCanvasSize,\n        sampling: sampling['canvas'],\n        dataURLOptions,\n        errorHandler,\n    });\n    const shadowDomManager = typeof __RRWEB_EXCLUDE_SHADOW_DOM__ === 'boolean' &&\n        __RRWEB_EXCLUDE_SHADOW_DOM__\n        ? new ShadowDomManagerNoop()\n        : new ShadowDomManager({\n            mutationCb: wrappedMutationEmit,\n            scrollCb: wrappedScrollEmit,\n            bypassOptions: {\n                onMutation,\n                blockClass,\n                blockSelector,\n                unblockSelector,\n                maskAllText,\n                maskTextClass,\n                unmaskTextClass,\n                maskTextSelector,\n                unmaskTextSelector,\n                inlineStylesheet,\n                maskInputOptions,\n                dataURLOptions,\n                maskAttributeFn,\n                maskTextFn,\n                maskInputFn,\n                recordCanvas,\n                inlineImages,\n                sampling,\n                slimDOMOptions,\n                iframeManager,\n                stylesheetManager,\n                canvasManager,\n                keepIframeSrcFn,\n                processedNodeManager,\n            },\n            mirror,\n        });\n    const takeFullSnapshot = (isCheckout = false) => {\n        if (!recordDOM) {\n            return;\n        }\n        wrappedEmit({\n            type: EventType.Meta,\n            data: {\n                href: window.location.href,\n                width: getWindowWidth(),\n                height: getWindowHeight(),\n            },\n        }, isCheckout);\n        stylesheetManager.reset();\n        shadowDomManager.init();\n        mutationBuffers.forEach((buf) => buf.lock());\n        const node = snapshot(document, {\n            mirror,\n            blockClass,\n            blockSelector,\n            unblockSelector,\n            maskAllText,\n            maskTextClass,\n            unmaskTextClass,\n            maskTextSelector,\n            unmaskTextSelector,\n            inlineStylesheet,\n            maskAllInputs: maskInputOptions,\n            maskAttributeFn,\n            maskInputFn,\n            maskTextFn,\n            slimDOM: slimDOMOptions,\n            dataURLOptions,\n            recordCanvas,\n            inlineImages,\n            onSerialize: (n) => {\n                if (isSerializedIframe(n, mirror)) {\n                    iframeManager.addIframe(n);\n                }\n                if (isSerializedStylesheet(n, mirror)) {\n                    stylesheetManager.trackLinkElement(n);\n                }\n                if (hasShadowRoot(n)) {\n                    shadowDomManager.addShadowRoot(n.shadowRoot, document);\n                }\n            },\n            onIframeLoad: (iframe, childSn) => {\n                iframeManager.attachIframe(iframe, childSn);\n                if (iframe.contentWindow) {\n                    canvasManager.addWindow(iframe.contentWindow);\n                }\n                shadowDomManager.observeAttachShadow(iframe);\n            },\n            onStylesheetLoad: (linkEl, childSn) => {\n                stylesheetManager.attachLinkElement(linkEl, childSn);\n            },\n            keepIframeSrcFn,\n        });\n        if (!node) {\n            return console.warn('Failed to snapshot the document');\n        }\n        wrappedEmit({\n            type: EventType.FullSnapshot,\n            data: {\n                node,\n                initialOffset: getWindowScroll(window),\n            },\n        });\n        mutationBuffers.forEach((buf) => buf.unlock());\n        if (document.adoptedStyleSheets && document.adoptedStyleSheets.length > 0)\n            stylesheetManager.adoptStyleSheets(document.adoptedStyleSheets, mirror.getId(document));\n    };\n    _takeFullSnapshot = takeFullSnapshot;\n    try {\n        const handlers = [];\n        const observe = (doc) => {\n            return callbackWrapper(initObservers)({\n                onMutation,\n                mutationCb: wrappedMutationEmit,\n                mousemoveCb: (positions, source) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source,\n                        positions,\n                    },\n                }),\n                mouseInteractionCb: (d) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.MouseInteraction,\n                        ...d,\n                    },\n                }),\n                scrollCb: wrappedScrollEmit,\n                viewportResizeCb: (d) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.ViewportResize,\n                        ...d,\n                    },\n                }),\n                inputCb: (v) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.Input,\n                        ...v,\n                    },\n                }),\n                mediaInteractionCb: (p) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.MediaInteraction,\n                        ...p,\n                    },\n                }),\n                styleSheetRuleCb: (r) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.StyleSheetRule,\n                        ...r,\n                    },\n                }),\n                styleDeclarationCb: (r) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.StyleDeclaration,\n                        ...r,\n                    },\n                }),\n                canvasMutationCb: wrappedCanvasMutationEmit,\n                fontCb: (p) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.Font,\n                        ...p,\n                    },\n                }),\n                selectionCb: (p) => {\n                    wrappedEmit({\n                        type: EventType.IncrementalSnapshot,\n                        data: {\n                            source: IncrementalSource.Selection,\n                            ...p,\n                        },\n                    });\n                },\n                customElementCb: (c) => {\n                    wrappedEmit({\n                        type: EventType.IncrementalSnapshot,\n                        data: {\n                            source: IncrementalSource.CustomElement,\n                            ...c,\n                        },\n                    });\n                },\n                blockClass,\n                ignoreClass,\n                ignoreSelector,\n                maskAllText,\n                maskTextClass,\n                unmaskTextClass,\n                maskTextSelector,\n                unmaskTextSelector,\n                maskInputOptions,\n                inlineStylesheet,\n                sampling,\n                recordDOM,\n                recordCanvas,\n                inlineImages,\n                userTriggeredOnInput,\n                collectFonts,\n                doc,\n                maskAttributeFn,\n                maskInputFn,\n                maskTextFn,\n                keepIframeSrcFn,\n                blockSelector,\n                unblockSelector,\n                slimDOMOptions,\n                dataURLOptions,\n                mirror,\n                iframeManager,\n                stylesheetManager,\n                shadowDomManager,\n                processedNodeManager,\n                canvasManager,\n                ignoreCSSAttributes,\n                plugins: plugins\n                    ?.filter((p) => p.observer)\n                    ?.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        iframeManager.addLoadListener((iframeEl) => {\n            try {\n                handlers.push(observe(iframeEl.contentDocument));\n            }\n            catch (error) {\n                console.warn(error);\n            }\n        });\n        const init = () => {\n            takeFullSnapshot();\n            handlers.push(observe(document));\n        };\n        if (document.readyState === 'interactive' ||\n            document.readyState === 'complete') {\n            init();\n        }\n        else {\n            handlers.push(on('DOMContentLoaded', () => {\n                wrappedEmit({\n                    type: EventType.DomContentLoaded,\n                    data: {},\n                });\n                if (recordAfter === 'DOMContentLoaded')\n                    init();\n            }));\n            handlers.push(on('load', () => {\n                wrappedEmit({\n                    type: EventType.Load,\n                    data: {},\n                });\n                if (recordAfter === 'load')\n                    init();\n            }, window));\n        }\n        return () => {\n            handlers.forEach((h) => h());\n            processedNodeManager.destroy();\n            _takeFullSnapshot = undefined;\n            unregisterErrorHandler();\n        };\n    }\n    catch (error) {\n        console.warn(error);\n    }\n}\nfunction takeFullSnapshot(isCheckout) {\n    if (!_takeFullSnapshot) {\n        throw new Error('please take full snapshot after start recording');\n    }\n    _takeFullSnapshot(isCheckout);\n}\nrecord.mirror = mirror;\nrecord.takeFullSnapshot = takeFullSnapshot;\nfunction _getCanvasManager(getCanvasManagerFn, options) {\n    try {\n        return getCanvasManagerFn\n            ? getCanvasManagerFn(options)\n            : new CanvasManagerNoop();\n    }\n    catch {\n        console.warn('Unable to initialize CanvasManager');\n        return new CanvasManagerNoop();\n    }\n}\n\nconst ReplayEventTypeIncrementalSnapshot = 3;\nconst ReplayEventTypeCustom = 5;\n\n/**\n * Converts a timestamp to ms, if it was in s, or keeps it as ms.\n */\nfunction timestampToMs(timestamp) {\n  const isMs = timestamp > 9999999999;\n  return isMs ? timestamp : timestamp * 1000;\n}\n\n/**\n * Converts a timestamp to s, if it was in ms, or keeps it as s.\n */\nfunction timestampToS(timestamp) {\n  const isMs = timestamp > 9999999999;\n  return isMs ? timestamp / 1000 : timestamp;\n}\n\n/**\n * Add a breadcrumb event to replay.\n */\nfunction addBreadcrumbEvent(replay, breadcrumb) {\n  if (breadcrumb.category === 'sentry.transaction') {\n    return;\n  }\n\n  if (['ui.click', 'ui.input'].includes(breadcrumb.category )) {\n    replay.triggerUserActivity();\n  } else {\n    replay.checkAndHandleExpiredSession();\n  }\n\n  replay.addUpdate(() => {\n    // This should never reject\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    replay.throttledAddEvent({\n      type: EventType.Custom,\n      // TODO: We were converting from ms to seconds for breadcrumbs, spans,\n      // but maybe we should just keep them as milliseconds\n      timestamp: (breadcrumb.timestamp || 0) * 1000,\n      data: {\n        tag: 'breadcrumb',\n        // normalize to max. 10 depth and 1_000 properties per object\n        payload: normalize(breadcrumb, 10, 1000),\n      },\n    });\n\n    // Do not flush after console log messages\n    return breadcrumb.category === 'console';\n  });\n}\n\nconst INTERACTIVE_SELECTOR = 'button,a';\n\n/** Get the closest interactive parent element, or else return the given element. */\nfunction getClosestInteractive(element) {\n  const closestInteractive = element.closest(INTERACTIVE_SELECTOR);\n  return closestInteractive || element;\n}\n\n/**\n * For clicks, we check if the target is inside of a button or link\n * If so, we use this as the target instead\n * This is useful because if you click on the image in <button><img></button>,\n * The target will be the image, not the button, which we don't want here\n */\nfunction getClickTargetNode(event) {\n  const target = getTargetNode(event);\n\n  if (!target || !(target instanceof Element)) {\n    return target;\n  }\n\n  return getClosestInteractive(target);\n}\n\n/** Get the event target node. */\nfunction getTargetNode(event) {\n  if (isEventWithTarget(event)) {\n    return event.target ;\n  }\n\n  return event;\n}\n\nfunction isEventWithTarget(event) {\n  return typeof event === 'object' && !!event && 'target' in event;\n}\n\nlet handlers;\n\n/**\n * Register a handler to be called when `window.open()` is called.\n * Returns a cleanup function.\n */\nfunction onWindowOpen(cb) {\n  // Ensure to only register this once\n  if (!handlers) {\n    handlers = [];\n    monkeyPatchWindowOpen();\n  }\n\n  handlers.push(cb);\n\n  return () => {\n    const pos = handlers ? handlers.indexOf(cb) : -1;\n    if (pos > -1) {\n      (handlers ).splice(pos, 1);\n    }\n  };\n}\n\nfunction monkeyPatchWindowOpen() {\n  fill(WINDOW, 'open', function (originalWindowOpen) {\n    return function (...args) {\n      if (handlers) {\n        try {\n          handlers.forEach(handler => handler());\n        } catch (e) {\n          // ignore errors in here\n        }\n      }\n\n      return originalWindowOpen.apply(WINDOW, args);\n    };\n  });\n}\n\n/** Any IncrementalSource for rrweb that we interpret as a kind of mutation. */\nconst IncrementalMutationSources = new Set([\n  IncrementalSource.Mutation,\n  IncrementalSource.StyleSheetRule,\n  IncrementalSource.StyleDeclaration,\n  IncrementalSource.AdoptedStyleSheet,\n  IncrementalSource.CanvasMutation,\n  IncrementalSource.Selection,\n  IncrementalSource.MediaInteraction,\n]);\n\n/** Handle a click. */\nfunction handleClick(clickDetector, clickBreadcrumb, node) {\n  clickDetector.handleClick(clickBreadcrumb, node);\n}\n\n/** A click detector class that can be used to detect slow or rage clicks on elements. */\nclass ClickDetector  {\n  // protected for testing\n\n   constructor(\n    replay,\n    slowClickConfig,\n    // Just for easier testing\n    _addBreadcrumbEvent = addBreadcrumbEvent,\n  ) {\n    this._lastMutation = 0;\n    this._lastScroll = 0;\n    this._clicks = [];\n\n    // We want everything in s, but options are in ms\n    this._timeout = slowClickConfig.timeout / 1000;\n    this._threshold = slowClickConfig.threshold / 1000;\n    this._scrollTimeout = slowClickConfig.scrollTimeout / 1000;\n    this._replay = replay;\n    this._ignoreSelector = slowClickConfig.ignoreSelector;\n    this._addBreadcrumbEvent = _addBreadcrumbEvent;\n  }\n\n  /** Register click detection handlers on mutation or scroll. */\n   addListeners() {\n    const cleanupWindowOpen = onWindowOpen(() => {\n      // Treat window.open as mutation\n      this._lastMutation = nowInSeconds();\n    });\n\n    this._teardown = () => {\n      cleanupWindowOpen();\n\n      this._clicks = [];\n      this._lastMutation = 0;\n      this._lastScroll = 0;\n    };\n  }\n\n  /** Clean up listeners. */\n   removeListeners() {\n    if (this._teardown) {\n      this._teardown();\n    }\n\n    if (this._checkClickTimeout) {\n      clearTimeout(this._checkClickTimeout);\n    }\n  }\n\n  /** @inheritDoc */\n   handleClick(breadcrumb, node) {\n    if (ignoreElement(node, this._ignoreSelector) || !isClickBreadcrumb(breadcrumb)) {\n      return;\n    }\n\n    const newClick = {\n      timestamp: timestampToS(breadcrumb.timestamp),\n      clickBreadcrumb: breadcrumb,\n      // Set this to 0 so we know it originates from the click breadcrumb\n      clickCount: 0,\n      node,\n    };\n\n    // If there was a click in the last 1s on the same element, ignore it - only keep a single reference per second\n    if (\n      this._clicks.some(click => click.node === newClick.node && Math.abs(click.timestamp - newClick.timestamp) < 1)\n    ) {\n      return;\n    }\n\n    this._clicks.push(newClick);\n\n    // If this is the first new click, set a timeout to check for multi clicks\n    if (this._clicks.length === 1) {\n      this._scheduleCheckClicks();\n    }\n  }\n\n  /** @inheritDoc */\n   registerMutation(timestamp = Date.now()) {\n    this._lastMutation = timestampToS(timestamp);\n  }\n\n  /** @inheritDoc */\n   registerScroll(timestamp = Date.now()) {\n    this._lastScroll = timestampToS(timestamp);\n  }\n\n  /** @inheritDoc */\n   registerClick(element) {\n    const node = getClosestInteractive(element);\n    this._handleMultiClick(node );\n  }\n\n  /** Count multiple clicks on elements. */\n   _handleMultiClick(node) {\n    this._getClicks(node).forEach(click => {\n      click.clickCount++;\n    });\n  }\n\n  /** Get all pending clicks for a given node. */\n   _getClicks(node) {\n    return this._clicks.filter(click => click.node === node);\n  }\n\n  /** Check the clicks that happened. */\n   _checkClicks() {\n    const timedOutClicks = [];\n\n    const now = nowInSeconds();\n\n    this._clicks.forEach(click => {\n      if (!click.mutationAfter && this._lastMutation) {\n        click.mutationAfter = click.timestamp <= this._lastMutation ? this._lastMutation - click.timestamp : undefined;\n      }\n      if (!click.scrollAfter && this._lastScroll) {\n        click.scrollAfter = click.timestamp <= this._lastScroll ? this._lastScroll - click.timestamp : undefined;\n      }\n\n      // All of these are in seconds!\n      if (click.timestamp + this._timeout <= now) {\n        timedOutClicks.push(click);\n      }\n    });\n\n    // Remove \"old\" clicks\n    for (const click of timedOutClicks) {\n      const pos = this._clicks.indexOf(click);\n\n      if (pos > -1) {\n        this._generateBreadcrumbs(click);\n        this._clicks.splice(pos, 1);\n      }\n    }\n\n    // Trigger new check, unless no clicks left\n    if (this._clicks.length) {\n      this._scheduleCheckClicks();\n    }\n  }\n\n  /** Generate matching breadcrumb(s) for the click. */\n   _generateBreadcrumbs(click) {\n    const replay = this._replay;\n    const hadScroll = click.scrollAfter && click.scrollAfter <= this._scrollTimeout;\n    const hadMutation = click.mutationAfter && click.mutationAfter <= this._threshold;\n\n    const isSlowClick = !hadScroll && !hadMutation;\n    const { clickCount, clickBreadcrumb } = click;\n\n    // Slow click\n    if (isSlowClick) {\n      // If `mutationAfter` is set, it means a mutation happened after the threshold, but before the timeout\n      // If not, it means we just timed out without scroll & mutation\n      const timeAfterClickMs = Math.min(click.mutationAfter || this._timeout, this._timeout) * 1000;\n      const endReason = timeAfterClickMs < this._timeout * 1000 ? 'mutation' : 'timeout';\n\n      const breadcrumb = {\n        type: 'default',\n        message: clickBreadcrumb.message,\n        timestamp: clickBreadcrumb.timestamp,\n        category: 'ui.slowClickDetected',\n        data: {\n          ...clickBreadcrumb.data,\n          url: WINDOW.location.href,\n          route: replay.getCurrentRoute(),\n          timeAfterClickMs,\n          endReason,\n          // If clickCount === 0, it means multiClick was not correctly captured here\n          // - we still want to send 1 in this case\n          clickCount: clickCount || 1,\n        },\n      };\n\n      this._addBreadcrumbEvent(replay, breadcrumb);\n      return;\n    }\n\n    // Multi click\n    if (clickCount > 1) {\n      const breadcrumb = {\n        type: 'default',\n        message: clickBreadcrumb.message,\n        timestamp: clickBreadcrumb.timestamp,\n        category: 'ui.multiClick',\n        data: {\n          ...clickBreadcrumb.data,\n          url: WINDOW.location.href,\n          route: replay.getCurrentRoute(),\n          clickCount,\n          metric: true,\n        },\n      };\n\n      this._addBreadcrumbEvent(replay, breadcrumb);\n    }\n  }\n\n  /** Schedule to check current clicks. */\n   _scheduleCheckClicks() {\n    if (this._checkClickTimeout) {\n      clearTimeout(this._checkClickTimeout);\n    }\n\n    this._checkClickTimeout = setTimeout$3(() => this._checkClicks(), 1000);\n  }\n}\n\nconst SLOW_CLICK_TAGS = ['A', 'BUTTON', 'INPUT'];\n\n/** exported for tests only */\nfunction ignoreElement(node, ignoreSelector) {\n  if (!SLOW_CLICK_TAGS.includes(node.tagName)) {\n    return true;\n  }\n\n  // If <input> tag, we only want to consider input[type='submit'] & input[type='button']\n  if (node.tagName === 'INPUT' && !['submit', 'button'].includes(node.getAttribute('type') || '')) {\n    return true;\n  }\n\n  // If <a> tag, detect special variants that may not lead to an action\n  // If target !== _self, we may open the link somewhere else, which would lead to no action\n  // Also, when downloading a file, we may not leave the page, but still not trigger an action\n  if (\n    node.tagName === 'A' &&\n    (node.hasAttribute('download') || (node.hasAttribute('target') && node.getAttribute('target') !== '_self'))\n  ) {\n    return true;\n  }\n\n  if (ignoreSelector && node.matches(ignoreSelector)) {\n    return true;\n  }\n\n  return false;\n}\n\nfunction isClickBreadcrumb(breadcrumb) {\n  return !!(breadcrumb.data && typeof breadcrumb.data.nodeId === 'number' && breadcrumb.timestamp);\n}\n\n// This is good enough for us, and is easier to test/mock than `timestampInSeconds`\nfunction nowInSeconds() {\n  return Date.now() / 1000;\n}\n\n/** Update the click detector based on a recording event of rrweb. */\nfunction updateClickDetectorForRecordingEvent(clickDetector, event) {\n  try {\n    // note: We only consider incremental snapshots here\n    // This means that any full snapshot is ignored for mutation detection - the reason is that we simply cannot know if a mutation happened here.\n    // E.g. think that we are buffering, an error happens and we take a full snapshot because we switched to session mode -\n    // in this scenario, we would not know if a dead click happened because of the error, which is a key dead click scenario.\n    // Instead, by ignoring full snapshots, we have the risk that we generate a false positive\n    // (if a mutation _did_ happen but was \"swallowed\" by the full snapshot)\n    // But this should be more unlikely as we'd generally capture the incremental snapshot right away\n\n    if (!isIncrementalEvent(event)) {\n      return;\n    }\n\n    const { source } = event.data;\n    if (IncrementalMutationSources.has(source)) {\n      clickDetector.registerMutation(event.timestamp);\n    }\n\n    if (source === IncrementalSource.Scroll) {\n      clickDetector.registerScroll(event.timestamp);\n    }\n\n    if (isIncrementalMouseInteraction(event)) {\n      const { type, id } = event.data;\n      const node = record.mirror.getNode(id);\n\n      if (node instanceof HTMLElement && type === MouseInteractions.Click) {\n        clickDetector.registerClick(node);\n      }\n    }\n  } catch {\n    // ignore errors here, e.g. if accessing something that does not exist\n  }\n}\n\nfunction isIncrementalEvent(event) {\n  return event.type === ReplayEventTypeIncrementalSnapshot;\n}\n\nfunction isIncrementalMouseInteraction(\n  event,\n) {\n  return event.data.source === IncrementalSource.MouseInteraction;\n}\n\n/**\n * Create a breadcrumb for a replay.\n */\nfunction createBreadcrumb(\n  breadcrumb,\n) {\n  return {\n    timestamp: Date.now() / 1000,\n    type: 'default',\n    ...breadcrumb,\n  };\n}\n\nvar NodeType;\n(function (NodeType) {\n    NodeType[NodeType[\"Document\"] = 0] = \"Document\";\n    NodeType[NodeType[\"DocumentType\"] = 1] = \"DocumentType\";\n    NodeType[NodeType[\"Element\"] = 2] = \"Element\";\n    NodeType[NodeType[\"Text\"] = 3] = \"Text\";\n    NodeType[NodeType[\"CDATA\"] = 4] = \"CDATA\";\n    NodeType[NodeType[\"Comment\"] = 5] = \"Comment\";\n})(NodeType || (NodeType = {}));\n\n// Note that these are the serialized attributes and not attributes directly on\n// the DOM Node. Attributes we are interested in:\nconst ATTRIBUTES_TO_RECORD = new Set([\n  'id',\n  'class',\n  'aria-label',\n  'role',\n  'name',\n  'alt',\n  'title',\n  'data-test-id',\n  'data-testid',\n  'disabled',\n  'aria-disabled',\n  'data-sentry-component',\n]);\n\n/**\n * Inclusion list of attributes that we want to record from the DOM element\n */\nfunction getAttributesToRecord(attributes) {\n  const obj = {};\n  if (!attributes['data-sentry-component'] && attributes['data-sentry-element']) {\n    attributes['data-sentry-component'] = attributes['data-sentry-element'];\n  }\n  for (const key in attributes) {\n    if (ATTRIBUTES_TO_RECORD.has(key)) {\n      let normalizedKey = key;\n\n      if (key === 'data-testid' || key === 'data-test-id') {\n        normalizedKey = 'testId';\n      }\n\n      obj[normalizedKey] = attributes[key];\n    }\n  }\n\n  return obj;\n}\n\nconst handleDomListener = (\n  replay,\n) => {\n  return (handlerData) => {\n    if (!replay.isEnabled()) {\n      return;\n    }\n\n    const result = handleDom(handlerData);\n\n    if (!result) {\n      return;\n    }\n\n    const isClick = handlerData.name === 'click';\n    const event = isClick ? (handlerData.event ) : undefined;\n    // Ignore clicks if ctrl/alt/meta/shift keys are held down as they alter behavior of clicks (e.g. open in new tab)\n    if (\n      isClick &&\n      replay.clickDetector &&\n      event &&\n      event.target &&\n      !event.altKey &&\n      !event.metaKey &&\n      !event.ctrlKey &&\n      !event.shiftKey\n    ) {\n      handleClick(\n        replay.clickDetector,\n        result ,\n        getClickTargetNode(handlerData.event ) ,\n      );\n    }\n\n    addBreadcrumbEvent(replay, result);\n  };\n};\n\n/** Get the base DOM breadcrumb. */\nfunction getBaseDomBreadcrumb(target, message) {\n  const nodeId = record.mirror.getId(target);\n  const node = nodeId && record.mirror.getNode(nodeId);\n  const meta = node && record.mirror.getMeta(node);\n  const element = meta && isElement(meta) ? meta : null;\n\n  return {\n    message,\n    data: element\n      ? {\n          nodeId,\n          node: {\n            id: nodeId,\n            tagName: element.tagName,\n            textContent: Array.from(element.childNodes)\n              .map((node) => node.type === NodeType.Text && node.textContent)\n              .filter(Boolean) // filter out empty values\n              .map(text => (text ).trim())\n              .join(''),\n            attributes: getAttributesToRecord(element.attributes),\n          },\n        }\n      : {},\n  };\n}\n\n/**\n * An event handler to react to DOM events.\n * Exported for tests.\n */\nfunction handleDom(handlerData) {\n  const { target, message } = getDomTarget(handlerData);\n\n  return createBreadcrumb({\n    category: `ui.${handlerData.name}`,\n    ...getBaseDomBreadcrumb(target, message),\n  });\n}\n\nfunction getDomTarget(handlerData) {\n  const isClick = handlerData.name === 'click';\n\n  let message;\n  let target = null;\n\n  // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n  try {\n    target = isClick ? getClickTargetNode(handlerData.event ) : getTargetNode(handlerData.event );\n    message = htmlTreeAsString(target, { maxStringLength: 200 }) || '<unknown>';\n  } catch (e) {\n    message = '<unknown>';\n  }\n\n  return { target, message };\n}\n\nfunction isElement(node) {\n  return node.type === NodeType.Element;\n}\n\n/** Handle keyboard events & create breadcrumbs. */\nfunction handleKeyboardEvent(replay, event) {\n  if (!replay.isEnabled()) {\n    return;\n  }\n\n  // Update user activity, but do not restart recording as it can create\n  // noisy/low-value replays (e.g. user comes back from idle, hits alt-tab, new\n  // session with a single \"keydown\" breadcrumb is created)\n  replay.updateUserActivity();\n\n  const breadcrumb = getKeyboardBreadcrumb(event);\n\n  if (!breadcrumb) {\n    return;\n  }\n\n  addBreadcrumbEvent(replay, breadcrumb);\n}\n\n/** exported only for tests */\nfunction getKeyboardBreadcrumb(event) {\n  const { metaKey, shiftKey, ctrlKey, altKey, key, target } = event;\n\n  // never capture for input fields\n  if (!target || isInputElement(target ) || !key) {\n    return null;\n  }\n\n  // Note: We do not consider shift here, as that means \"uppercase\"\n  const hasModifierKey = metaKey || ctrlKey || altKey;\n  const isCharacterKey = key.length === 1; // other keys like Escape, Tab, etc have a longer length\n\n  // Do not capture breadcrumb if only a word key is pressed\n  // This could leak e.g. user input\n  if (!hasModifierKey && isCharacterKey) {\n    return null;\n  }\n\n  const message = htmlTreeAsString(target, { maxStringLength: 200 }) || '<unknown>';\n  const baseBreadcrumb = getBaseDomBreadcrumb(target , message);\n\n  return createBreadcrumb({\n    category: 'ui.keyDown',\n    message,\n    data: {\n      ...baseBreadcrumb.data,\n      metaKey,\n      shiftKey,\n      ctrlKey,\n      altKey,\n      key,\n    },\n  });\n}\n\nfunction isInputElement(target) {\n  return target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable;\n}\n\n// Map entryType -> function to normalize data for event\nconst ENTRY_TYPES\n\n = {\n  // @ts-expect-error TODO: entry type does not fit the create* functions entry type\n  resource: createResourceEntry,\n  paint: createPaintEntry,\n  // @ts-expect-error TODO: entry type does not fit the create* functions entry type\n  navigation: createNavigationEntry,\n};\n\n/**\n * Handler creater for web vitals\n */\nfunction webVitalHandler(\n  getter,\n  replay,\n) {\n  return ({ metric }) => void replay.replayPerformanceEntries.push(getter(metric));\n}\n\n/**\n * Create replay performance entries from the browser performance entries.\n */\nfunction createPerformanceEntries(\n  entries,\n) {\n  return entries.map(createPerformanceEntry).filter(Boolean) ;\n}\n\nfunction createPerformanceEntry(entry) {\n  const entryType = ENTRY_TYPES[entry.entryType];\n  if (!entryType) {\n    return null;\n  }\n\n  return entryType(entry);\n}\n\nfunction getAbsoluteTime(time) {\n  // browserPerformanceTimeOrigin can be undefined if `performance` or\n  // `performance.now` doesn't exist, but this is already checked by this integration\n  return ((browserPerformanceTimeOrigin() || WINDOW.performance.timeOrigin) + time) / 1000;\n}\n\nfunction createPaintEntry(entry) {\n  const { duration, entryType, name, startTime } = entry;\n\n  const start = getAbsoluteTime(startTime);\n  return {\n    type: entryType,\n    name,\n    start,\n    end: start + duration,\n    data: undefined,\n  };\n}\n\nfunction createNavigationEntry(entry) {\n  const {\n    entryType,\n    name,\n    decodedBodySize,\n    duration,\n    domComplete,\n    encodedBodySize,\n    domContentLoadedEventStart,\n    domContentLoadedEventEnd,\n    domInteractive,\n    loadEventStart,\n    loadEventEnd,\n    redirectCount,\n    startTime,\n    transferSize,\n    type,\n  } = entry;\n\n  // Ignore entries with no duration, they do not seem to be useful and cause dupes\n  if (duration === 0) {\n    return null;\n  }\n\n  return {\n    type: `${entryType}.${type}`,\n    start: getAbsoluteTime(startTime),\n    end: getAbsoluteTime(domComplete),\n    name,\n    data: {\n      size: transferSize,\n      decodedBodySize,\n      encodedBodySize,\n      duration,\n      domInteractive,\n      domContentLoadedEventStart,\n      domContentLoadedEventEnd,\n      loadEventStart,\n      loadEventEnd,\n      domComplete,\n      redirectCount,\n    },\n  };\n}\n\nfunction createResourceEntry(\n  entry,\n) {\n  const {\n    entryType,\n    initiatorType,\n    name,\n    responseEnd,\n    startTime,\n    decodedBodySize,\n    encodedBodySize,\n    responseStatus,\n    transferSize,\n  } = entry;\n\n  // Core SDK handles these\n  if (['fetch', 'xmlhttprequest'].includes(initiatorType)) {\n    return null;\n  }\n\n  return {\n    type: `${entryType}.${initiatorType}`,\n    start: getAbsoluteTime(startTime),\n    end: getAbsoluteTime(responseEnd),\n    name,\n    data: {\n      size: transferSize,\n      statusCode: responseStatus,\n      decodedBodySize,\n      encodedBodySize,\n    },\n  };\n}\n\n/**\n * Add a LCP event to the replay based on a LCP metric.\n */\nfunction getLargestContentfulPaint(metric) {\n  const lastEntry = metric.entries[metric.entries.length - 1] ;\n  const node = lastEntry?.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: dropUndefinedKeys({\n      method,\n      statusCode,\n      request,\n      response,\n    }),\n  };\n\n  return result;\n}\n\n/** Build the request or response part of a replay network breadcrumb that was skipped. */\nfunction buildSkippedNetworkRequestOrResponse(bodySize) {\n  return {\n    headers: {},\n    size: bodySize,\n    _meta: {\n      warnings: ['URL_SKIPPED'],\n    },\n  };\n}\n\n/** Build the request or response part of a replay network breadcrumb. */\nfunction buildNetworkRequestOrResponse(\n  headers,\n  bodySize,\n  body,\n) {\n  if (!bodySize && Object.keys(headers).length === 0) {\n    return undefined;\n  }\n\n  if (!bodySize) {\n    return {\n      headers,\n    };\n  }\n\n  if (!body) {\n    return {\n      headers,\n      size: bodySize,\n    };\n  }\n\n  const info = {\n    headers,\n    size: bodySize,\n  };\n\n  const { body: normalizedBody, warnings } = normalizeNetworkBody(body);\n  info.body = normalizedBody;\n  if (warnings?.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    };\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    ...dropUndefinedKeys(initialOptions),\n  };\n\n  const replaysSessionSampleRate = parseSampleRate(opt.replaysSessionSampleRate);\n  const replaysOnErrorSampleRate = parseSampleRate(opt.replaysOnErrorSampleRate);\n\n  if (replaysSessionSampleRate == null && replaysOnErrorSampleRate == null) {\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.warn(\n        'Replay is disabled because neither `replaysSessionSampleRate` nor `replaysOnErrorSampleRate` are set.',\n      );\n    });\n  }\n\n  if (replaysSessionSampleRate != null) {\n    finalOptions.sessionSampleRate = replaysSessionSampleRate;\n  }\n\n  if (replaysOnErrorSampleRate != null) {\n    finalOptions.errorSampleRate = replaysOnErrorSampleRate;\n  }\n\n  return finalOptions;\n}\n\nfunction _getMergedNetworkHeaders(headers) {\n  return [...DEFAULT_NETWORK_HEADERS, ...headers.map(header => header.toLowerCase())];\n}\n\n/**\n * This is a small utility to get a type-safe instance of the Replay integration.\n */\nfunction getReplay() {\n  const client = getClient();\n  return client?.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","NodeType$3","isShadowRoot","n","host","Boolean","shadowRoot","isNativeShadowDom","Object","prototype","toString","call","stringifyStylesheet","s","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","i","styleDeclaration","attribute","isImportant","getPropertyPriority","getPropertyValue","fixAllCssProperty","cssStringified","regex","fixSafariColons","NodeType","Mirror","constructor","this","idNodeMap","Map","nodeMetaMap","WeakMap","getId","id","getMeta","getNode","get","getIds","keys","removeNodeFromMap","delete","childNodes","forEach","childNode","has","hasNode","node","add","meta","set","oldNode","reset","shouldMaskInput","maskInputOptions","tagName","type","toLowerCase","maskInputValue","isMasked","element","value","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","document","impl","createElement","sandbox","hidden","head","appendChild","contentWindow","removeChild","e","bind","setTimeout$2","rest","clearTimeout$2","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","a","startsWith","setAttribute","transformAttribute","maskAttributeFn","pos","collectCharacters","regEx","chars","exec","substring","output","descriptorsStr","inParens","c","charAt","getAbsoluteSrcsetString","ignoreAttribute","_value","distanceToMatch","matchPredicate","limit","Infinity","distance","nodeType","ELEMENT_NODE","parentNode","createMatchPredicate","className","selector","matches","eIndex","classList","elementClassMatchesRegex","needMaskingText","maskTextClass","maskTextSelector","unmaskTextClass","unmaskTextSelector","maskAllText","parentElement","autocomplete","maskDistance","unmaskDistance","serializeNode","options","mirror","blockClass","blockSelector","unblockSelector","inlineStylesheet","maskTextFn","dataURLOptions","inlineImages","recordCanvas","keepIframeSrcFn","newlyAddedElement","rootId","docId","undefined","getRootId","DOCUMENT_NODE","compatMode","Document","DOCUMENT_TYPE_NODE","DocumentType","publicId","systemId","needBlock","contains","_isBlockedElement","HTMLFormElement","processedTagName","getValidTagName","attributes","len","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","serializedNode","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$1","apply","trailing","setTimeout$1","hookSetter","key","d","isRevoked","original","getOwnPropertyDescriptor","defineProperty","patch","source","replacement","wrapped","defineProperties","__rrweb_original__","enumerable","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","NodeType$1","NodeType$2","EventType","EventType2","IncrementalSource","IncrementalSource2","MouseInteractions","MouseInteractions2","PointerTypes","PointerTypes2","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","r","_isParentRemoved","size","_isAncestorInSet","errorHandler","registerErrorHandler","handler","unregisterErrorHandler","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","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","v","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","configurable","sheets","result","adoptStyleSheets","initObservers","o","_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","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","obj","isArray","child","ShadowDomManagerNoop","ShadowDomManager","shadowDoms","WeakSet","restoreHandlers","patchAttachShadow","iframeElement","iframeWindow","getIFrameContentWindow","manager","option","resetShadowRoots","CanvasManagerNoop","snapshot","StylesheetManager","trackedLinkElements","adoptedStyleSheetCb","linkEl","trackStylesheetInLinkElement","adoptedStyleSheetData","styleIds","CSSRule","ProcessedNodeManager","nodeMap","active","thisBuffer","buffers","onRequestAnimationFrame","destroy","_takeFullSnapshot","cleanFrame","debug","record","checkoutEveryNms","checkoutEveryNth","maskAllInputs","_maskInputOptions","_slimDOMOptions","maxCanvasSize","packFn","mousemoveWait","recordAfter","getCanvasManager","inEmittingFrame","parent","passEmitsToParent","color","date","email","month","number","search","tel","time","week","select","radio","checkbox","lastFullSnapshotEvent","NodeList","DOMTokenList","TypeError","polyfill","incrementalSnapshotCount","eventProcessor","buf","postMessage","exceedCount","exceedTime","takeFullSnapshot","wrappedMutationEmit","wrappedScrollEmit","wrappedCanvasMutationEmit","__RRWEB_EXCLUDE_IFRAME__","getMirror","nodeMirror","getCanvasManagerFn","_getCanvasManager","__RRWEB_EXCLUDE_SHADOW_DOM__","slimDOM","initialOffset","canvasMutationCb","CustomElement","ReplayEventTypeIncrementalSnapshot","timestampToMs","timestampToS","addBreadcrumbEvent","replay","breadcrumb","category","triggerUserActivity","checkAndHandleExpiredSession","addUpdate","throttledAddEvent","tag","INTERACTIVE_SELECTOR","getClosestInteractive","closest","getClickTargetNode","getTargetNode","isEventWithTarget","onWindowOpen","originalWindowOpen","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","scrollAfter","_generateBreadcrumbs","hadScroll","hadMutation","isSlowClick","timeAfterClickMs","endReason","route","getCurrentRoute","metric","updateClickDetectorForRecordingEvent","clickDetector","isIncrementalEvent","isIncrementalMouseInteraction","HTMLElement","createBreadcrumb","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__","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","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":""}