{"version":3,"file":"b3a13d7d-3b0e74cf20d1e352bad9.js","mappings":"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","sources":["webpack://uw-change-chart/./node_modules/@sentry/replay/esm/index.js"],"sourcesContent":["import { getCurrentHub, isSentryRequestUrl, addGlobalEventProcessor, prepareEvent, setContext, captureException } from '@sentry/core';\nimport { GLOBAL_OBJ, normalize, fill, htmlTreeAsString, browserPerformanceTimeOrigin, logger, uuid4, SENTRY_XHR_DATA_KEY, dropUndefinedKeys, stringMatchesSomePattern, addInstrumentationHandler, createEnvelope, createEventEnvelopeHeaders, getSdkMetadataForEnvelopeHeader, updateRateLimits, isRateLimited, isBrowser } from '@sentry/utils';\nimport { addPerformanceInstrumentationHandler, addLcpInstrumentationHandler } from '@sentry-internal/tracing';\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$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 = {}));\n\nfunction isElement$1(n) {\n    return n.nodeType === n.ELEMENT_NODE;\n}\nfunction isShadowRoot(n) {\n    const host = n === null || n === void 0 ? void 0 : n.host;\n    return Boolean((host === null || host === void 0 ? void 0 : 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(' background-clip: text;', ' -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 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) && rule.selectorText.includes(':')) {\n        return fixSafariColons(rule.cssText);\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        var _a;\n        if (!n)\n            return -1;\n        const id = (_a = this.getMeta(n)) === null || _a === void 0 ? void 0 : _a.id;\n        return id !== null && id !== void 0 ? 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}\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}\nfunction absoluteToDoc(doc, attributeValue) {\n    if (!attributeValue || attributeValue.trim() === '') {\n        return attributeValue;\n    }\n    const a = doc.createElement('a');\n    a.href = attributeValue;\n    return a.href;\n}\nfunction isSVGElement(el) {\n    return Boolean(el.tagName === 'svg' || el.ownerSVGElement);\n}\nfunction getHref() {\n    const a = document.createElement('a');\n    a.href = '';\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());\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        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}\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        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(() => {\n            if (!fired) {\n                listener();\n                fired = true;\n            }\n        }, iframeLoadTimeout);\n        iframeEl.addEventListener('load', () => {\n            clearTimeout(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(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(() => {\n        if (!fired) {\n            listener();\n            fired = true;\n        }\n    }, styleSheetLoadTimeout);\n    link.addEventListener('load', () => {\n        clearTimeout(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$1.Document,\n                    childNodes: [],\n                    compatMode: n.compatMode,\n                };\n            }\n            else {\n                return {\n                    type: NodeType$1.Document,\n                    childNodes: [],\n                };\n            }\n        case n.DOCUMENT_TYPE_NODE:\n            return {\n                type: NodeType$1.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                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$1.CDATA,\n                textContent: '',\n                rootId,\n            };\n        case n.COMMENT_NODE:\n            return {\n                type: NodeType$1.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    var _a;\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 ((_a = n.parentNode.sheet) === null || _a === void 0 ? void 0 : _a.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());\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            : 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$1.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 (!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            delete attributes.rel;\n            delete attributes.href;\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());\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 = document.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 oldValue = image.crossOrigin;\n        image.crossOrigin = 'anonymous';\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                console.warn(`Cannot inline img src=${image.currentSrc}! Error: ${err}`);\n            }\n            oldValue\n                ? (attributes.crossOrigin = oldValue)\n                : image.removeAttribute('crossorigin');\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 (!n.contentDocument) {\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$1.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$1.Comment) {\n        return true;\n    }\n    else if (sn.type === NodeType$1.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.attributes.as === 'script') ||\n                (sn.tagName === 'link' &&\n                    sn.attributes.rel === 'prefetch' &&\n                    typeof sn.attributes.href === 'string' &&\n                    sn.attributes.href.endsWith('.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$1.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$1.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$1.Document ||\n        serializedNode.type === NodeType$1.Element) &&\n        recordChild) {\n        if (slimDOMOptions.headWhitespace &&\n            serializedNode.type === NodeType$1.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$1.Element &&\n        serializedNode.tagName === 'iframe') {\n        onceIframeLoaded(n, () => {\n            const iframeDoc = n.contentDocument;\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$1.Element &&\n        serializedNode.tagName === 'link' &&\n        serializedNode.attributes.rel === 'stylesheet') {\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(timeout);\n                timeout = null;\n            }\n            previous = now;\n            func.apply(context, args);\n        }\n        else if (!timeout && options.trailing !== false) {\n            timeout = setTimeout(() => {\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(() => {\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 (_a) {\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    var _a, _b, _c, _d, _e, _f;\n    const doc = win.document;\n    return {\n        left: doc.scrollingElement\n            ? doc.scrollingElement.scrollLeft\n            : win.pageXOffset !== undefined\n                ? win.pageXOffset\n                : (doc === null || doc === void 0 ? void 0 : doc.documentElement.scrollLeft) ||\n                    ((_b = (_a = doc === null || doc === void 0 ? void 0 : doc.body) === null || _a === void 0 ? void 0 : _a.parentElement) === null || _b === void 0 ? void 0 : _b.scrollLeft) ||\n                    ((_c = doc === null || doc === void 0 ? void 0 : doc.body) === null || _c === void 0 ? void 0 : _c.scrollLeft) ||\n                    0,\n        top: doc.scrollingElement\n            ? doc.scrollingElement.scrollTop\n            : win.pageYOffset !== undefined\n                ? win.pageYOffset\n                : (doc === null || doc === void 0 ? void 0 : doc.documentElement.scrollTop) ||\n                    ((_e = (_d = doc === null || doc === void 0 ? void 0 : doc.body) === null || _d === void 0 ? void 0 : _d.parentElement) === null || _e === void 0 ? void 0 : _e.scrollTop) ||\n                    ((_f = doc === null || doc === void 0 ? void 0 : doc.body) === null || _f === void 0 ? void 0 : _f.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 isBlocked(node, blockClass, blockSelector, unblockSelector, checkAncestors) {\n    if (!node) {\n        return false;\n    }\n    const el = node.nodeType === node.ELEMENT_NODE\n        ? node\n        : node.parentElement;\n    if (!el)\n        return false;\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 === null || n === void 0 ? void 0 : 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        var _a;\n        return (_a = this.styleIDMap.get(stylesheet)) !== null && _a !== void 0 ? _a : -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    var _a, _b;\n    let shadowHost = null;\n    if (((_b = (_a = n.getRootNode) === null || _a === void 0 ? void 0 : _a.call(n)) === null || _b === void 0 ? void 0 : _b.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}\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\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 === null || current === void 0 ? void 0 : 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.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                            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                        this.iframeManager.attachIframe(iframe, childSn);\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.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            let unattachedDoc;\n            try {\n                unattachedDoc = document.implementation.createHTMLDocument();\n            }\n            catch (e) {\n                unattachedDoc = this.doc;\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)\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.attributes.find((a) => a.node === m.target);\n                    if (target.tagName === 'IFRAME' &&\n                        attributeName === 'src' &&\n                        !this.keepIframeSrcFn(value)) {\n                        if (!target.contentDocument) {\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                    }\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                            const old = 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    const { parentNode } = n;\n    if (!parentNode) {\n        return false;\n    }\n    const parentId = mirror.getId(parentNode);\n    if (removes.some((r) => r.id === parentId)) {\n        return true;\n    }\n    return _isParentRemoved(removes, parentNode, mirror);\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 (_a) {\n    }\n    return event && event.target;\n}\nfunction initMutationObserver(options, rootEl) {\n    var _a, _b;\n    const mutationBuffer = new MutationBuffer();\n    mutationBuffers.push(mutationBuffer);\n    mutationBuffer.init(options);\n    let mutationObserverCtor = window.MutationObserver ||\n        window.__rrMutationObserver;\n    const angularZoneSymbol = (_b = (_a = window === null || window === void 0 ? void 0 : window.Zone) === null || _a === void 0 ? void 0 : _a.__symbol__) === null || _b === void 0 ? void 0 : _b.call(_a, '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)(Object.assign({ type: MouseInteractions[thisEventKey], id, x: clientX, y: clientY }, (pointerType !== null && { pointerType })));\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)(Object.assign(Object.assign({}, v), { id }));\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    var _a, _b, _c;\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        ? (_a = host.defaultView) === null || _a === void 0 ? void 0 : _a.Document\n        : (_c = (_b = host.ownerDocument) === null || _b === void 0 ? void 0 : _b.defaultView) === null || _c === void 0 ? void 0 : _c.ShadowRoot;\n    const originalPropertyDescriptor = (patchTarget === null || patchTarget === void 0 ? void 0 : patchTarget.prototype)\n        ? Object.getOwnPropertyDescriptor(patchTarget === null || patchTarget === void 0 ? void 0 : 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            var _a;\n            return (_a = originalPropertyDescriptor.get) === null || _a === void 0 ? void 0 : _a.call(this);\n        },\n        set(sheets) {\n            var _a;\n            const result = (_a = originalPropertyDescriptor.set) === null || _a === void 0 ? void 0 : _a.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            var _a;\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((_a = thisArg.parentRule) === null || _a === void 0 ? void 0 : _a.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            var _a;\n            const [property] = argumentsList;\n            if (ignoreCSSAttributes.has(property)) {\n                return removeProperty.apply(thisArg, [property]);\n            }\n            const { id, styleId } = getIdAndStyleId((_a = thisArg.parentRule) === null || _a === void 0 ? void 0 : _a.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(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 === null || selection === void 0 ? void 0 : 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        };\n    }\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    const mutationObserver = initMutationObserver(o, o.doc);\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    const styleSheetObserver = initStyleSheetObserver(o, { win: currentWindow });\n    const adoptedStyleSheetObserver = initAdoptedStyleSheetObserver(o, o.doc);\n    const styleDeclarationObserver = initStyleDeclarationObserver(o, {\n        win: currentWindow,\n    });\n    const fontObserver = o.collectFonts\n        ? initFontObserver(o)\n        : () => {\n        };\n    const selectionObserver = initSelectionObserver(o);\n    const customElementObserver = initCustomElementObserver(o);\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    });\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        var _a;\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        (_a = this.loadListener) === null || _a === void 0 ? void 0 : _a.call(this, iframeEl);\n        if (iframeEl.contentDocument &&\n            iframeEl.contentDocument.adoptedStyleSheets &&\n            iframeEl.contentDocument.adoptedStyleSheets.length > 0)\n            this.stylesheetManager.adoptStyleSheets(iframeEl.contentDocument.adoptedStyleSheets, this.mirror.getId(iframeEl.contentDocument));\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        var _a;\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                        (_a = e.data.styles) === null || _a === void 0 ? void 0 : _a.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$1.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        const observer = initMutationObserver(Object.assign(Object.assign({}, this.bypassOptions), { doc, mutationCb: this.mutationCb, mirror: this.mirror, shadowDomManager: this }), shadowRoot);\n        this.restoreHandlers.push(() => observer.disconnect());\n        this.restoreHandlers.push(initScrollObserver(Object.assign(Object.assign({}, this.bypassOptions), { scrollCb: this.scrollCb, doc: shadowRoot, mirror: this.mirror })));\n        setTimeout(() => {\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        if (!iframeElement.contentWindow || !iframeElement.contentDocument)\n            return;\n        this.patchAttachShadow(iframeElement.contentWindow.Element, iframeElement.contentDocument);\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    }\n}\n\nclass CanvasManagerNoop {\n    reset() {\n    }\n    freeze() {\n    }\n    unfreeze() {\n    }\n    lock() {\n    }\n    unlock() {\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.loop = true;\n        this.periodicallyClear();\n    }\n    periodicallyClear() {\n        requestAnimationFrame(() => {\n            this.clear();\n            if (this.loop)\n                this.periodicallyClear();\n        });\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        this.nodeMap.set(node, (this.nodeMap.get(node) || new Set()).add(buffer));\n    }\n    clear() {\n        this.nodeMap = new WeakMap();\n    }\n    destroy() {\n        this.loop = false;\n    }\n}\n\nfunction wrapEvent(e) {\n    const eWithTime = e;\n    eWithTime.timestamp = nowTimestamp();\n    return eWithTime;\n}\nlet _takeFullSnapshot;\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, packFn, sampling = {}, dataURLOptions = {}, mousemoveWait, recordCanvas = false, recordCrossOriginIframes = false, recordAfter = options.recordAfter === 'DOMContentLoaded'\n        ? options.recordAfter\n        : 'load', userTriggeredOnInput = false, collectFonts = false, inlineImages = false, 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 (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        if (packFn &&\n            !passEmitsToParent) {\n            e = packFn(e);\n        }\n        return e;\n    };\n    const wrappedEmit = (e, isCheckout) => {\n        var _a;\n        if (((_a = mutationBuffers[0]) === null || _a === void 0 ? void 0 : _a.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 === null || emit === void 0 ? void 0 : 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                e.timestamp - lastFullSnapshotEvent.timestamp > checkoutEveryNms;\n            if (exceedCount || exceedTime) {\n                takeFullSnapshot(true);\n            }\n        }\n    };\n    const wrappedMutationEmit = (m) => {\n        wrappedEmit(wrapEvent({\n            type: EventType.IncrementalSnapshot,\n            data: Object.assign({ source: IncrementalSource.Mutation }, m),\n        }));\n    };\n    const wrappedScrollEmit = (p) => wrappedEmit(wrapEvent({\n        type: EventType.IncrementalSnapshot,\n        data: Object.assign({ source: IncrementalSource.Scroll }, p),\n    }));\n    const wrappedCanvasMutationEmit = (p) => wrappedEmit(wrapEvent({\n        type: EventType.IncrementalSnapshot,\n        data: Object.assign({ source: IncrementalSource.CanvasMutation }, p),\n    }));\n    const wrappedAdoptedStyleSheetEmit = (a) => wrappedEmit(wrapEvent({\n        type: EventType.IncrementalSnapshot,\n        data: Object.assign({ source: IncrementalSource.AdoptedStyleSheet }, a),\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    const processedNodeManager = new ProcessedNodeManager();\n    const canvasManager = getCanvasManager\n        ? getCanvasManager({\n            recordCanvas,\n            blockClass,\n            blockSelector,\n            unblockSelector,\n            sampling: sampling['canvas'],\n            dataURLOptions,\n        })\n        : new CanvasManagerNoop();\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        wrappedEmit(wrapEvent({\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                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(wrapEvent({\n            type: EventType.FullSnapshot,\n            data: {\n                node,\n                initialOffset: getWindowScroll(window),\n            },\n        }), isCheckout);\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(wrapEvent({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source,\n                        positions,\n                    },\n                })),\n                mouseInteractionCb: (d) => wrappedEmit(wrapEvent({\n                    type: EventType.IncrementalSnapshot,\n                    data: Object.assign({ source: IncrementalSource.MouseInteraction }, d),\n                })),\n                scrollCb: wrappedScrollEmit,\n                viewportResizeCb: (d) => wrappedEmit(wrapEvent({\n                    type: EventType.IncrementalSnapshot,\n                    data: Object.assign({ source: IncrementalSource.ViewportResize }, d),\n                })),\n                inputCb: (v) => wrappedEmit(wrapEvent({\n                    type: EventType.IncrementalSnapshot,\n                    data: Object.assign({ source: IncrementalSource.Input }, v),\n                })),\n                mediaInteractionCb: (p) => wrappedEmit(wrapEvent({\n                    type: EventType.IncrementalSnapshot,\n                    data: Object.assign({ source: IncrementalSource.MediaInteraction }, p),\n                })),\n                styleSheetRuleCb: (r) => wrappedEmit(wrapEvent({\n                    type: EventType.IncrementalSnapshot,\n                    data: Object.assign({ source: IncrementalSource.StyleSheetRule }, r),\n                })),\n                styleDeclarationCb: (r) => wrappedEmit(wrapEvent({\n                    type: EventType.IncrementalSnapshot,\n                    data: Object.assign({ source: IncrementalSource.StyleDeclaration }, r),\n                })),\n                canvasMutationCb: wrappedCanvasMutationEmit,\n                fontCb: (p) => wrappedEmit(wrapEvent({\n                    type: EventType.IncrementalSnapshot,\n                    data: Object.assign({ source: IncrementalSource.Font }, p),\n                })),\n                selectionCb: (p) => {\n                    wrappedEmit(wrapEvent({\n                        type: EventType.IncrementalSnapshot,\n                        data: Object.assign({ source: IncrementalSource.Selection }, p),\n                    }));\n                },\n                customElementCb: (c) => {\n                    wrappedEmit(wrapEvent({\n                        type: EventType.IncrementalSnapshot,\n                        data: Object.assign({ source: IncrementalSource.CustomElement }, c),\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                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: [],\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(wrapEvent({\n                    type: EventType.DomContentLoaded,\n                    data: {},\n                }));\n                if (recordAfter === 'DOMContentLoaded')\n                    init();\n            }));\n            handlers.push(on('load', () => {\n                wrappedEmit(wrapEvent({\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;\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    void 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/** 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._scollTimeout = slowClickConfig.scrollTimeout / 1000;\n    this._replay = replay;\n    this._ignoreSelector = slowClickConfig.ignoreSelector;\n    this._addBreadcrumbEvent = _addBreadcrumbEvent;\n  }\n\n  /** Register click detection handlers on mutation or scroll. */\n   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._scollTimeout;\n    const hadMutation = click.mutationAfter && click.mutationAfter <= this._threshold;\n\n    const isSlowClick = !hadScroll && !hadMutation;\n    const { clickCount, clickBreadcrumb } = click;\n\n    // Slow click\n    if (isSlowClick) {\n      // If `mutationAfter` is set, it means a mutation happened after the threshold, but before the timeout\n      // If not, it means we just timed out without scroll & mutation\n      const timeAfterClickMs = Math.min(click.mutationAfter || this._timeout, this._timeout) * 1000;\n      const endReason = timeAfterClickMs < this._timeout * 1000 ? 'mutation' : 'timeout';\n\n      const breadcrumb = {\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(() => 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 (source === IncrementalSource.Mutation) {\n      clickDetector.registerMutation(event.timestamp);\n    }\n\n    if (source === IncrementalSource.Scroll) {\n      clickDetector.registerScroll(event.timestamp);\n    }\n\n    if (isIncrementalMouseInteraction(event)) {\n      const { type, id } = event.data;\n      const node = record.mirror.getNode(id);\n\n      if (node instanceof HTMLElement && type === MouseInteractions.Click) {\n        clickDetector.registerClick(node);\n      }\n    }\n  } catch (e) {\n    // ignore errors here, e.g. if accessing something that does not exist\n  }\n}\n\nfunction isIncrementalEvent(event) {\n  return event.type === ReplayEventTypeIncrementalSnapshot;\n}\n\nfunction isIncrementalMouseInteraction(\n  event,\n) {\n  return event.data.source === IncrementalSource.MouseInteraction;\n}\n\n/**\n * Create a breadcrumb for a replay.\n */\nfunction createBreadcrumb(\n  breadcrumb,\n) {\n  return {\n    timestamp: Date.now() / 1000,\n    type: 'default',\n    ...breadcrumb,\n  };\n}\n\nvar NodeType;\n(function (NodeType) {\n    NodeType[NodeType[\"Document\"] = 0] = \"Document\";\n    NodeType[NodeType[\"DocumentType\"] = 1] = \"DocumentType\";\n    NodeType[NodeType[\"Element\"] = 2] = \"Element\";\n    NodeType[NodeType[\"Text\"] = 3] = \"Text\";\n    NodeType[NodeType[\"CDATA\"] = 4] = \"CDATA\";\n    NodeType[NodeType[\"Comment\"] = 5] = \"Comment\";\n})(NodeType || (NodeType = {}));\n\n// Note that these are the serialized attributes and not attributes directly on\n// the DOM Node. Attributes we are interested in:\nconst ATTRIBUTES_TO_RECORD = new Set([\n  'id',\n  'class',\n  'aria-label',\n  'role',\n  'name',\n  'alt',\n  'title',\n  'data-test-id',\n  'data-testid',\n  'disabled',\n  'aria-disabled',\n]);\n\n/**\n * Inclusion list of attributes that we want to record from the DOM element\n */\nfunction getAttributesToRecord(attributes) {\n  const obj = {};\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 );\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.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 * 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  if (!ENTRY_TYPES[entry.entryType]) {\n    return null;\n  }\n\n  return ENTRY_TYPES[entry.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 an LCP metric.\n */\nfunction getLargestContentfulPaint(metric\n\n) {\n  const entries = metric.entries;\n  const lastEntry = entries[entries.length - 1] ;\n  const element = lastEntry ? lastEntry.element : undefined;\n\n  const value = metric.value;\n\n  const end = getAbsoluteTime(value);\n\n  const data = {\n    type: 'largest-contentful-paint',\n    name: 'largest-contentful-paint',\n    start: end,\n    end,\n    data: {\n      value,\n      size: value,\n      nodeId: element ? record.mirror.getId(element) : undefined,\n    },\n  };\n\n  return data;\n}\n\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(({ metric }) => {\n      replay.replayPerformanceEntries.push(getLargestContentfulPaint(metric));\n    }),\n  );\n\n  // A callback to cleanup all handlers\n  return () => {\n    clearCallbacks.forEach(clearCallback => clearCallback());\n  };\n}\n\nconst r = `var t=Uint8Array,n=Uint16Array,r=Int32Array,e=new t([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0,0]),i=new t([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,0,0]),a=new t([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),s=function(t,e){for(var i=new n(31),a=0;a<31;++a)i[a]=e+=1<<t[a-1];var s=new r(i[30]);for(a=1;a<30;++a)for(var o=i[a];o<i[a+1];++o)s[o]=o-i[a]<<5|a;return{b:i,r:s}},o=s(e,2),f=o.b,h=o.r;f[28]=258,h[258]=28;for(var l=s(i,0).r,u=new n(32768),c=0;c<32768;++c){var v=(43690&c)>>1|(21845&c)<<1;v=(61680&(v=(52428&v)>>2|(13107&v)<<2))>>4|(3855&v)<<4,u[c]=((65280&v)>>8|(255&v)<<8)>>1}var d=function(t,r,e){for(var i=t.length,a=0,s=new n(r);a<i;++a)t[a]&&++s[t[a]-1];var o,f=new n(r);for(a=1;a<r;++a)f[a]=f[a-1]+s[a-1]<<1;if(e){o=new n(1<<r);var h=15-r;for(a=0;a<i;++a)if(t[a])for(var l=a<<4|t[a],c=r-t[a],v=f[t[a]-1]++<<c,d=v|(1<<c)-1;v<=d;++v)o[u[v]>>h]=l}else for(o=new n(i),a=0;a<i;++a)t[a]&&(o[a]=u[f[t[a]-1]++]>>15-t[a]);return o},g=new t(288);for(c=0;c<144;++c)g[c]=8;for(c=144;c<256;++c)g[c]=9;for(c=256;c<280;++c)g[c]=7;for(c=280;c<288;++c)g[c]=8;var w=new t(32);for(c=0;c<32;++c)w[c]=5;var p=d(g,9,0),y=d(w,5,0),m=function(t){return(t+7)/8|0},b=function(n,r,e){return(null==r||r<0)&&(r=0),(null==e||e>n.length)&&(e=n.length),new t(n.subarray(r,e))},M=[\"unexpected EOF\",\"invalid block type\",\"invalid length/literal\",\"invalid distance\",\"stream finished\",\"no stream handler\",,\"no callback\",\"invalid UTF-8 data\",\"extra field too long\",\"date not in range 1980-2099\",\"filename too long\",\"stream finishing\",\"invalid zip data\"],E=function(t,n,r){var e=new Error(n||M[t]);if(e.code=t,Error.captureStackTrace&&Error.captureStackTrace(e,E),!r)throw e;return e},z=function(t,n,r){r<<=7&n;var e=n/8|0;t[e]|=r,t[e+1]|=r>>8},A=function(t,n,r){r<<=7&n;var e=n/8|0;t[e]|=r,t[e+1]|=r>>8,t[e+2]|=r>>16},_=function(r,e){for(var i=[],a=0;a<r.length;++a)r[a]&&i.push({s:a,f:r[a]});var s=i.length,o=i.slice();if(!s)return{t:F,l:0};if(1==s){var f=new t(i[0].s+1);return f[i[0].s]=1,{t:f,l:1}}i.sort((function(t,n){return t.f-n.f})),i.push({s:-1,f:25001});var h=i[0],l=i[1],u=0,c=1,v=2;for(i[0]={s:-1,f:h.f+l.f,l:h,r:l};c!=s-1;)h=i[i[u].f<i[v].f?u++:v++],l=i[u!=c&&i[u].f<i[v].f?u++:v++],i[c++]={s:-1,f:h.f+l.f,l:h,r:l};var d=o[0].s;for(a=1;a<s;++a)o[a].s>d&&(d=o[a].s);var g=new n(d+1),w=x(i[c-1],g,0);if(w>e){a=0;var p=0,y=w-e,m=1<<y;for(o.sort((function(t,n){return g[n.s]-g[t.s]||t.f-n.f}));a<s;++a){var b=o[a].s;if(!(g[b]>e))break;p+=m-(1<<w-g[b]),g[b]=e}for(p>>=y;p>0;){var M=o[a].s;g[M]<e?p-=1<<e-g[M]++-1:++a}for(;a>=0&&p;--a){var E=o[a].s;g[E]==e&&(--g[E],++p)}w=e}return{t:new t(g),l:w}},x=function(t,n,r){return-1==t.s?Math.max(x(t.l,n,r+1),x(t.r,n,r+1)):n[t.s]=r},D=function(t){for(var r=t.length;r&&!t[--r];);for(var e=new n(++r),i=0,a=t[0],s=1,o=function(t){e[i++]=t},f=1;f<=r;++f)if(t[f]==a&&f!=r)++s;else{if(!a&&s>2){for(;s>138;s-=138)o(32754);s>2&&(o(s>10?s-11<<5|28690:s-3<<5|12305),s=0)}else if(s>3){for(o(a),--s;s>6;s-=6)o(8304);s>2&&(o(s-3<<5|8208),s=0)}for(;s--;)o(a);s=1,a=t[f]}return{c:e.subarray(0,i),n:r}},T=function(t,n){for(var r=0,e=0;e<n.length;++e)r+=t[e]*n[e];return r},k=function(t,n,r){var e=r.length,i=m(n+2);t[i]=255&e,t[i+1]=e>>8,t[i+2]=255^t[i],t[i+3]=255^t[i+1];for(var a=0;a<e;++a)t[i+a+4]=r[a];return 8*(i+4+e)},C=function(t,r,s,o,f,h,l,u,c,v,m){z(r,m++,s),++f[256];for(var b=_(f,15),M=b.t,E=b.l,x=_(h,15),C=x.t,U=x.l,F=D(M),I=F.c,S=F.n,L=D(C),O=L.c,j=L.n,q=new n(19),B=0;B<I.length;++B)++q[31&I[B]];for(B=0;B<O.length;++B)++q[31&O[B]];for(var G=_(q,7),H=G.t,J=G.l,K=19;K>4&&!H[a[K-1]];--K);var N,P,Q,R,V=v+5<<3,W=T(f,g)+T(h,w)+l,X=T(f,M)+T(h,C)+l+14+3*K+T(q,H)+2*q[16]+3*q[17]+7*q[18];if(c>=0&&V<=W&&V<=X)return k(r,m,t.subarray(c,c+v));if(z(r,m,1+(X<W)),m+=2,X<W){N=d(M,E,0),P=M,Q=d(C,U,0),R=C;var Y=d(H,J,0);z(r,m,S-257),z(r,m+5,j-1),z(r,m+10,K-4),m+=14;for(B=0;B<K;++B)z(r,m+3*B,H[a[B]]);m+=3*K;for(var Z=[I,O],$=0;$<2;++$){var tt=Z[$];for(B=0;B<tt.length;++B){var nt=31&tt[B];z(r,m,Y[nt]),m+=H[nt],nt>15&&(z(r,m,tt[B]>>5&127),m+=tt[B]>>12)}}}else N=p,P=g,Q=y,R=w;for(B=0;B<u;++B){var rt=o[B];if(rt>255){A(r,m,N[(nt=rt>>18&31)+257]),m+=P[nt+257],nt>7&&(z(r,m,rt>>23&31),m+=e[nt]);var et=31&rt;A(r,m,Q[et]),m+=R[et],et>3&&(A(r,m,rt>>5&8191),m+=i[et])}else A(r,m,N[rt]),m+=P[rt]}return A(r,m,N[256]),m+P[256]},U=new r([65540,131080,131088,131104,262176,1048704,1048832,2114560,2117632]),F=new t(0),I=function(){for(var t=new Int32Array(256),n=0;n<256;++n){for(var r=n,e=9;--e;)r=(1&r&&-306674912)^r>>>1;t[n]=r}return t}(),S=function(){var t=1,n=0;return{p:function(r){for(var e=t,i=n,a=0|r.length,s=0;s!=a;){for(var o=Math.min(s+2655,a);s<o;++s)i+=e+=r[s];e=(65535&e)+15*(e>>16),i=(65535&i)+15*(i>>16)}t=e,n=i},d:function(){return(255&(t%=65521))<<24|(65280&t)<<8|(255&(n%=65521))<<8|n>>8}}},L=function(a,s,o,f,u){if(!u&&(u={l:1},s.dictionary)){var c=s.dictionary.subarray(-32768),v=new t(c.length+a.length);v.set(c),v.set(a,c.length),a=v,u.w=c.length}return function(a,s,o,f,u,c){var v=c.z||a.length,d=new t(f+v+5*(1+Math.ceil(v/7e3))+u),g=d.subarray(f,d.length-u),w=c.l,p=7&(c.r||0);if(s){p&&(g[0]=c.r>>3);for(var y=U[s-1],M=y>>13,E=8191&y,z=(1<<o)-1,A=c.p||new n(32768),_=c.h||new n(z+1),x=Math.ceil(o/3),D=2*x,T=function(t){return(a[t]^a[t+1]<<x^a[t+2]<<D)&z},F=new r(25e3),I=new n(288),S=new n(32),L=0,O=0,j=c.i||0,q=0,B=c.w||0,G=0;j+2<v;++j){var H=T(j),J=32767&j,K=_[H];if(A[J]=K,_[H]=J,B<=j){var N=v-j;if((L>7e3||q>24576)&&(N>423||!w)){p=C(a,g,0,F,I,S,O,q,G,j-G,p),q=L=O=0,G=j;for(var P=0;P<286;++P)I[P]=0;for(P=0;P<30;++P)S[P]=0}var Q=2,R=0,V=E,W=J-K&32767;if(N>2&&H==T(j-W))for(var X=Math.min(M,N)-1,Y=Math.min(32767,j),Z=Math.min(258,N);W<=Y&&--V&&J!=K;){if(a[j+Q]==a[j+Q-W]){for(var $=0;$<Z&&a[j+$]==a[j+$-W];++$);if($>Q){if(Q=$,R=W,$>X)break;var tt=Math.min(W,$-2),nt=0;for(P=0;P<tt;++P){var rt=j-W+P&32767,et=rt-A[rt]&32767;et>nt&&(nt=et,K=rt)}}}W+=(J=K)-(K=A[J])&32767}if(R){F[q++]=268435456|h[Q]<<18|l[R];var it=31&h[Q],at=31&l[R];O+=e[it]+i[at],++I[257+it],++S[at],B=j+Q,++L}else F[q++]=a[j],++I[a[j]]}}for(j=Math.max(j,B);j<v;++j)F[q++]=a[j],++I[a[j]];p=C(a,g,w,F,I,S,O,q,G,j-G,p),w||(c.r=7&p|g[p/8|0]<<3,p-=7,c.h=_,c.p=A,c.i=j,c.w=B)}else{for(j=c.w||0;j<v+w;j+=65535){var st=j+65535;st>=v&&(g[p/8|0]=w,st=v),p=k(g,p+1,a.subarray(j,st))}c.i=v}return b(d,0,f+m(p)+u)}(a,null==s.level?6:s.level,null==s.mem?Math.ceil(1.5*Math.max(8,Math.min(13,Math.log(a.length)))):12+s.mem,o,f,u)},O=function(t,n,r){for(;r;++n)t[n]=r,r>>>=8},j=function(){function n(n,r){if(\"function\"==typeof n&&(r=n,n={}),this.ondata=r,this.o=n||{},this.s={l:0,i:32768,w:32768,z:32768},this.b=new t(98304),this.o.dictionary){var e=this.o.dictionary.subarray(-32768);this.b.set(e,32768-e.length),this.s.i=32768-e.length}}return n.prototype.p=function(t,n){this.ondata(L(t,this.o,0,0,this.s),n)},n.prototype.push=function(n,r){this.ondata||E(5),this.s.l&&E(4);var e=n.length+this.s.z;if(e>this.b.length){if(e>2*this.b.length-32768){var i=new t(-32768&e);i.set(this.b.subarray(0,this.s.z)),this.b=i}var a=this.b.length-this.s.z;a&&(this.b.set(n.subarray(0,a),this.s.z),this.s.z=this.b.length,this.p(this.b,!1)),this.b.set(this.b.subarray(-32768)),this.b.set(n.subarray(a),32768),this.s.z=n.length-a+32768,this.s.i=32766,this.s.w=32768}else this.b.set(n,this.s.z),this.s.z+=n.length;this.s.l=1&r,(this.s.z>this.s.w+8191||r)&&(this.p(this.b,r||!1),this.s.w=this.s.i,this.s.i-=2)},n}();function q(t,n){n||(n={});var r=function(){var t=-1;return{p:function(n){for(var r=t,e=0;e<n.length;++e)r=I[255&r^n[e]]^r>>>8;t=r},d:function(){return~t}}}(),e=t.length;r.p(t);var i,a=L(t,n,10+((i=n).filename?i.filename.length+1:0),8),s=a.length;return function(t,n){var r=n.filename;if(t[0]=31,t[1]=139,t[2]=8,t[8]=n.level<2?4:9==n.level?2:0,t[9]=3,0!=n.mtime&&O(t,4,Math.floor(new Date(n.mtime||Date.now())/1e3)),r){t[3]=8;for(var e=0;e<=r.length;++e)t[e+10]=r.charCodeAt(e)}}(a,n),O(a,s-8,r.d()),O(a,s-4,e),a}var B=function(){function t(t,n){this.c=S(),this.v=1,j.call(this,t,n)}return t.prototype.push=function(t,n){this.c.p(t),j.prototype.push.call(this,t,n)},t.prototype.p=function(t,n){var r=L(t,this.o,this.v&&(this.o.dictionary?6:2),n&&4,this.s);this.v&&(function(t,n){var r=n.level,e=0==r?0:r<6?1:9==r?3:2;if(t[0]=120,t[1]=e<<6|(n.dictionary&&32),t[1]|=31-(t[0]<<8|t[1])%31,n.dictionary){var i=S();i.p(n.dictionary),O(t,2,i.d())}}(r,this.o),this.v=0),n&&O(r,r.length-4,this.c.d()),this.ondata(r,n)},t}(),G=\"undefined\"!=typeof TextEncoder&&new TextEncoder,H=\"undefined\"!=typeof TextDecoder&&new TextDecoder;try{H.decode(F,{stream:!0})}catch(t){}var J=function(){function t(t){this.ondata=t}return t.prototype.push=function(t,n){this.ondata||E(5),this.d&&E(4),this.ondata(K(t),this.d=n||!1)},t}();function K(n,r){if(r){for(var e=new t(n.length),i=0;i<n.length;++i)e[i]=n.charCodeAt(i);return e}if(G)return G.encode(n);var a=n.length,s=new t(n.length+(n.length>>1)),o=0,f=function(t){s[o++]=t};for(i=0;i<a;++i){if(o+5>s.length){var h=new t(o+8+(a-i<<1));h.set(s),s=h}var l=n.charCodeAt(i);l<128||r?f(l):l<2048?(f(192|l>>6),f(128|63&l)):l>55295&&l<57344?(f(240|(l=65536+(1047552&l)|1023&n.charCodeAt(++i))>>18),f(128|l>>12&63),f(128|l>>6&63),f(128|63&l)):(f(224|l>>12),f(128|l>>6&63),f(128|63&l))}return b(s,0,o)}const N=new class{constructor(){this._init()}clear(){this._init()}addEvent(t){if(!t)throw new Error(\"Adding invalid event\");const n=this._hasEvents?\",\":\"\";this.stream.push(n+t),this._hasEvents=!0}finish(){this.stream.push(\"]\",!0);const t=function(t){let n=0;for(let r=0,e=t.length;r<e;r++)n+=t[r].length;const r=new Uint8Array(n);for(let n=0,e=0,i=t.length;n<i;n++){const i=t[n];r.set(i,e),e+=i.length}return r}(this._deflatedData);return this._init(),t}_init(){this._hasEvents=!1,this._deflatedData=[],this.deflate=new B,this.deflate.ondata=(t,n)=>{this._deflatedData.push(t)},this.stream=new J(((t,n)=>{this.deflate.push(t,n)})),this.stream.push(\"[\")}},P={clear:()=>{N.clear()},addEvent:t=>N.addEvent(t),finish:()=>N.finish(),compress:t=>function(t){return q(K(t))}(t)};addEventListener(\"message\",(function(t){const n=t.data.method,r=t.data.id,e=t.data.arg;if(n in P&&\"function\"==typeof P[n])try{const t=P[n](e);postMessage({id:r,method:n,success:!0,response:t})}catch(t){postMessage({id:r,method:n,success:!1,response:t.message}),console.error(t)}})),postMessage({id:void 0,method:\"init\",success:!0,response:void 0});`;\n\nfunction e(){const e=new Blob([r]);return URL.createObjectURL(e)}\n\n/**\n * Log a message in debug mode, and add a breadcrumb when _experiment.traceInternals is enabled.\n */\nfunction logInfo(message, shouldAddBreadcrumb) {\n  if (!(typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n    return;\n  }\n\n  logger.info(message);\n\n  if (shouldAddBreadcrumb) {\n    addBreadcrumb(message);\n  }\n}\n\n/**\n * Log a message, and add a breadcrumb in the next tick.\n * This is necessary when the breadcrumb may be added before the replay is initialized.\n */\nfunction logInfoNextTick(message, shouldAddBreadcrumb) {\n  if (!(typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__)) {\n    return;\n  }\n\n  logger.info(message);\n\n  if (shouldAddBreadcrumb) {\n    // Wait a tick here to avoid race conditions for some initial logs\n    // which may be added before replay is initialized\n    setTimeout(() => {\n      addBreadcrumb(message);\n    }, 0);\n  }\n}\n\nfunction addBreadcrumb(message) {\n  const hub = getCurrentHub();\n  hub.addBreadcrumb(\n    {\n      category: 'console',\n      data: {\n        logger: 'replay',\n      },\n      level: 'info',\n      message,\n    },\n    { level: 'info' },\n  );\n}\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   constructor() {\n    this.events = [];\n    this._totalSize = 0;\n    this.hasCheckout = 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 occured.\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    logInfo('[Replay] Destroying compression worker');\n    this._worker.terminate();\n  }\n\n  /**\n   * Post message to worker and wait for response before resolving promise.\n   */\n   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          (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('[Replay]', 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   constructor(worker) {\n    this._worker = new WorkerHandler(worker);\n    this._earliestTimestamp = null;\n    this._totalSize = 0;\n    this.hasCheckout = 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 occured.\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 successfuly 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    void this._worker.postMessage('clear');\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 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   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      logInfo('[Replay] Failed to load the compression worker, falling back to simple buffer');\n      return;\n    }\n\n    // Now we need to switch over the array buffer to the compression worker\n    await this._switchToCompressionWorker();\n  }\n\n  /** Switch the used buffer to the compression worker. */\n   async _switchToCompressionWorker() {\n    const { events, hasCheckout } = 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\n    // We switch over to the new buffer immediately - any further events will be added\n    // after the previously buffered ones\n    this._used = this._compression;\n\n    // Wait for original events to be re-added before resolving\n    try {\n      await Promise.all(addEventPromises);\n    } catch (error) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('[Replay] Failed to add events when switching buffers.', error);\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  logInfo('[Replay] 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    logInfo(`[Replay] Using compression worker${customWorkerUrl ? ` from ${customWorkerUrl}` : ''}`);\n    const worker = new Worker(workerUrl);\n    return new EventBufferProxy(worker);\n  } catch (error) {\n    logInfo('[Replay] Failed to create compression worker');\n    // Fall back to use simple event buffer array\n  }\n}\n\nfunction _getWorkerUrl() {\n  if (typeof __SENTRY_EXCLUDE_REPLAY_WORKER__ === 'undefined' || !__SENTRY_EXCLUDE_REPLAY_WORKER__) {\n    return e();\n  }\n\n  return '';\n}\n\n/** If sessionStorage is available. */\nfunction hasSessionStorage() {\n  try {\n    // This can throw, e.g. when being accessed in a sandboxed iframe\n    return 'sessionStorage' in WINDOW && !!WINDOW.sessionStorage;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Removes the session from Session Storage and unsets session in replay instance\n */\nfunction clearSession(replay) {\n  deleteSession();\n  replay.session = undefined;\n}\n\n/**\n * Deletes a session from storage\n */\nfunction deleteSession() {\n  if (!hasSessionStorage()) {\n    return;\n  }\n\n  try {\n    WINDOW.sessionStorage.removeItem(REPLAY_SESSION_KEY);\n  } catch (e) {\n    // Ignore potential SecurityError exceptions\n  }\n}\n\n/**\n * Given a sample rate, returns true if replay should be sampled.\n *\n * 1.0 = 100% sampling\n * 0.0 = 0% sampling\n */\nfunction isSampled(sampleRate) {\n  if (sampleRate === undefined) {\n    return false;\n  }\n\n  // Math.random() returns a number in range of 0 to 1 (inclusive of 0, but not 1)\n  return Math.random() < sampleRate;\n}\n\n/**\n * Save a session to session storage.\n */\nfunction saveSession(session) {\n  if (!hasSessionStorage()) {\n    return;\n  }\n\n  try {\n    WINDOW.sessionStorage.setItem(REPLAY_SESSION_KEY, JSON.stringify(session));\n  } catch (e) {\n    // Ignore potential SecurityError exceptions\n  }\n}\n\n/**\n * Get 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 * 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(traceInternals) {\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    logInfoNextTick('[Replay] Loading existing session', traceInternals);\n\n    return makeSession(sessionObj);\n  } catch (e) {\n    return null;\n  }\n}\n\n/**\n * Given an initial timestamp and an expiry duration, checks to see if current\n * time should be considered as expired.\n */\nfunction isExpired(\n  initialTime,\n  expiry,\n  targetTime = +new Date(),\n) {\n  // Always expired if < 0\n  if (initialTime === null || expiry === undefined || expiry < 0) {\n    return true;\n  }\n\n  // Never expires if == 0\n  if (expiry === 0) {\n    return false;\n  }\n\n  return initialTime + expiry <= targetTime;\n}\n\n/**\n * Checks to see if session is expired\n */\nfunction isSessionExpired(\n  session,\n  {\n    maxReplayDuration,\n    sessionIdleExpire,\n    targetTime = Date.now(),\n  },\n) {\n  return (\n    // First, check that maximum session length has not been exceeded\n    isExpired(session.started, maxReplayDuration, targetTime) ||\n    // check that the idle timeout has not been exceeded (i.e. user has\n    // performed an action within the last `sessionIdleExpire` ms)\n    isExpired(session.lastActivity, sessionIdleExpire, targetTime)\n  );\n}\n\n/** If the session should be refreshed or not. */\nfunction shouldRefreshSession(\n  session,\n  { sessionIdleExpire, maxReplayDuration },\n) {\n  // If not expired, all good, just keep the session\n  if (!isSessionExpired(session, { sessionIdleExpire, maxReplayDuration })) {\n    return false;\n  }\n\n  // If we are buffering & haven't ever flushed yet, always continue\n  if (session.sampled === 'buffer' && session.segmentId === 0) {\n    return false;\n  }\n\n  return true;\n}\n\n/**\n * Get or create a session, when initializing the replay.\n * Returns a session that may be unsampled.\n */\nfunction loadOrCreateSession(\n  {\n    traceInternals,\n    sessionIdleExpire,\n    maxReplayDuration,\n    previousSessionId,\n  }\n\n,\n  sessionOptions,\n) {\n  const existingSession = sessionOptions.stickySession && fetchSession(traceInternals);\n\n  // No session exists yet, just create a new one\n  if (!existingSession) {\n    logInfoNextTick('[Replay] Creating new session', traceInternals);\n    return createSession(sessionOptions, { previousSessionId });\n  }\n\n  if (!shouldRefreshSession(existingSession, { sessionIdleExpire, maxReplayDuration })) {\n    return existingSession;\n  }\n\n  logInfoNextTick('[Replay] Session in sessionStorage is expired, creating new one...');\n  return createSession(sessionOptions, { previousSessionId: existingSession.id });\n}\n\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  void _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  if (!replay.eventBuffer) {\n    return null;\n  }\n\n  try {\n    if (isCheckout && replay.recordingMode === 'buffer') {\n      replay.eventBuffer.clear();\n    }\n\n    if (isCheckout) {\n      replay.eventBuffer.hasCheckout = true;\n    }\n\n    const replayOptions = replay.getOptions();\n\n    const eventAfterPossibleCallback = maybeApplyCallback(event, replayOptions.beforeAddRecordingEvent);\n\n    if (!eventAfterPossibleCallback) {\n      return;\n    }\n\n    return await replay.eventBuffer.addEvent(eventAfterPossibleCallback);\n  } catch (error) {\n    const reason = error && error instanceof EventBufferSizeExceededError ? 'addEventSizeExceeded' : 'addEvent';\n\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(error);\n    await replay.stop({ reason });\n\n    const client = getCurrentHub().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    logInfo(\n      `[Replay] Skipping event with timestamp ${timestampInMs} because it is after maxReplayDuration`,\n      replay.getOptions()._experiments.traceInternals,\n    );\n    return false;\n  }\n\n  return true;\n}\n\nfunction maybeApplyCallback(\n  event,\n  callback,\n) {\n  try {\n    if (typeof callback === 'function' && isCustomEvent(event)) {\n      return callback(event);\n    }\n  } catch (error) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) &&\n      logger.error('[Replay] An error occured in the `beforeAddRecordingEvent` callback, skipping the event...', error);\n    return null;\n  }\n\n  return event;\n}\n\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/**\n * Returns a listener to be added to `client.on('afterSendErrorEvent, listener)`.\n */\nfunction handleAfterSendEvent(replay) {\n  // Custom transports may still be returning `Promise<void>`, which means we cannot expect the status code to be available there\n  // TODO (v8): remove this check as it will no longer be necessary\n  const enforceStatusCode = isBaseTransportSend();\n\n  return (event, sendResponse) => {\n    if (!replay.isEnabled() || (!isErrorEvent(event) && !isTransactionEvent(event))) {\n      return;\n    }\n\n    const statusCode = sendResponse && sendResponse.statusCode;\n\n    // We only want to do stuff on successful error sending, otherwise you get error replays without errors attached\n    // If not using the base transport, we allow `undefined` response (as a custom transport may not implement this correctly yet)\n    // If we do use the base transport, we skip if we encountered an non-OK status code\n    if (enforceStatusCode && (!statusCode || statusCode < 200 || statusCode >= 300)) {\n      return;\n    }\n\n    if (isTransactionEvent(event)) {\n      handleTransactionEvent(replay, event);\n      return;\n    }\n\n    handleErrorEvent(replay, event);\n  };\n}\n\nfunction handleTransactionEvent(replay, event) {\n  const replayContext = replay.getContext();\n\n  // Collect traceIds in _context regardless of `recordingMode`\n  // In error mode, _context gets cleared on every checkout\n  // We limit to max. 100 transactions linked\n  if (event.contexts && event.contexts.trace && event.contexts.trace.trace_id && replayContext.traceIds.size < 100) {\n    replayContext.traceIds.add(event.contexts.trace.trace_id );\n  }\n}\n\nfunction handleErrorEvent(replay, event) {\n  const replayContext = replay.getContext();\n\n  // Add error to list of errorIds of replay. This is ok to do even if not\n  // sampled because context will get reset at next checkout.\n  // XXX: There is also a race condition where it's possible to capture an\n  // error to Sentry before Replay SDK has loaded, but response returns after\n  // it was loaded, and this gets called.\n  // We limit to max. 100 errors linked\n  if (event.event_id && replayContext.errorIds.size < 100) {\n    replayContext.errorIds.add(event.event_id);\n  }\n\n  // If error event is tagged with replay id it means it was sampled (when in buffer mode)\n  // Need to be very careful that this does not cause an infinite loop\n  if (replay.recordingMode !== 'buffer' || !event.tags || !event.tags.replayId) {\n    return;\n  }\n\n  const { beforeErrorSampling } = replay.getOptions();\n  if (typeof beforeErrorSampling === 'function' && !beforeErrorSampling(event)) {\n    return;\n  }\n\n  setTimeout(() => {\n    // Capture current event buffer as new replay\n    void replay.sendBufferedReplayOrFlush();\n  });\n}\n\nfunction isBaseTransportSend() {\n  const client = getCurrentHub().getClient();\n  if (!client) {\n    return false;\n  }\n\n  const transport = client.getTransport();\n  if (!transport) {\n    return false;\n  }\n\n  return (\n    (transport.send ).__sentry__baseTransport__ || false\n  );\n}\n\n/**\n * Returns true if we think the given event is an error originating inside of rrweb.\n */\nfunction isRrwebError(event, hint) {\n  if (event.type || !event.exception || !event.exception.values || !event.exception.values.length) {\n    return false;\n  }\n\n  // @ts-expect-error this may be set by rrweb when it finds errors\n  if (hint.originalException && hint.originalException.__rrweb__) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Determine if event should be sampled (only applies in buffer mode).\n * When an event is captured by `hanldleGlobalEvent`, when in buffer mode\n * we determine if we want to sample the error or not.\n */\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 `addGlobalEventProcessor(listener)`.\n */\nfunction handleGlobalEventListener(\n  replay,\n  includeAfterSendEventHandling = false,\n) {\n  const afterSendHandler = includeAfterSendEventHandling ? handleAfterSendEvent(replay) : undefined;\n\n  return Object.assign(\n    (event, hint) => {\n      // Do nothing if replay has been disabled\n      if (!replay.isEnabled()) {\n        return event;\n      }\n\n      if (isReplayEvent(event)) {\n        // Replays have separate set of breadcrumbs, do not include breadcrumbs\n        // from core SDK\n        delete event.breadcrumbs;\n        return event;\n      }\n\n      // We only want to handle errors & transactions, nothing else\n      if (!isErrorEvent(event) && !isTransactionEvent(event)) {\n        return event;\n      }\n\n      // Ensure we do not add replay_id if the session is expired\n      const isSessionActive = replay.checkAndHandleExpiredSession();\n      if (!isSessionActive) {\n        return event;\n      }\n\n      // 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        (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.log('[Replay] Ignoring error from rrweb internals', event);\n        return null;\n      }\n\n      // When in buffer mode, we decide to sample here.\n      // Later, in `handleAfterSendEvent`, if the replayId is set, we know that we sampled\n      // And convert the buffer session to a full session\n      const isErrorEventSampled = shouldSampleForBufferEvent(replay, event);\n\n      // Tag errors if it has been sampled in buffer mode, or if it is session mode\n      // Only tag transactions if in session mode\n      const shouldTagReplayId = isErrorEventSampled || replay.recordingMode === 'session';\n\n      if (shouldTagReplayId) {\n        event.tags = { ...event.tags, replayId: replay.getSessionId() };\n      }\n\n      // In cases where a custom client is used that does not support the new hooks (yet),\n      // we manually call this hook method here\n      if (afterSendHandler) {\n        // Pretend the error had a 200 response so we always capture it\n        afterSendHandler(event, { statusCode: 200 });\n      }\n\n      return event;\n    },\n    { id: 'Replay' },\n  );\n}\n\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 `addInstrumentationHandler('history', 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 ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && replay.getOptions()._experiments.traceInternals) {\n    return false;\n  }\n\n  return isSentryRequestUrl(url, getCurrentHub());\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/** only exported for tests */\nfunction handleFetch(handlerData) {\n  const { startTimestamp, endTimestamp, fetchData, response } = handlerData;\n\n  if (!endTimestamp) {\n    return null;\n  }\n\n  // This is only used as a fallback, so we know the body sizes are never set here\n  const { method, url } = fetchData;\n\n  return {\n    type: 'resource.fetch',\n    start: startTimestamp / 1000,\n    end: endTimestamp / 1000,\n    name: url,\n    data: {\n      method,\n      statusCode: response ? (response ).status : undefined,\n    },\n  };\n}\n\n/**\n * Returns a listener to be added to `addInstrumentationHandler('fetch', listener)`.\n */\nfunction handleFetchSpanListener(replay) {\n  return (handlerData) => {\n    if (!replay.isEnabled()) {\n      return;\n    }\n\n    const result = handleFetch(handlerData);\n\n    addNetworkBreadcrumb(replay, result);\n  };\n}\n\n/** only exported for tests */\nfunction handleXhr(handlerData) {\n  const { startTimestamp, endTimestamp, xhr } = handlerData;\n\n  const sentryXhrData = xhr[SENTRY_XHR_DATA_KEY];\n\n  if (!startTimestamp || !endTimestamp || !sentryXhrData) {\n    return null;\n  }\n\n  // This is only used as a fallback, so we know the body sizes are never set here\n  const { method, url, status_code: statusCode } = sentryXhrData;\n\n  if (url === undefined) {\n    return null;\n  }\n\n  return {\n    type: 'resource.xhr',\n    name: url,\n    start: startTimestamp / 1000,\n    end: endTimestamp / 1000,\n    data: {\n      method,\n      statusCode,\n    },\n  };\n}\n\n/**\n * Returns a listener to be added to `addInstrumentationHandler('xhr', listener)`.\n */\nfunction handleXhrSpanListener(replay) {\n  return (handlerData) => {\n    if (!replay.isEnabled()) {\n      return;\n    }\n\n    const result = handleXhr(handlerData);\n\n    addNetworkBreadcrumb(replay, result);\n  };\n}\n\n/** Get the size of a body. */\nfunction getBodySize(\n  body,\n  textEncoder,\n) {\n  if (!body) {\n    return undefined;\n  }\n\n  try {\n    if (typeof body === 'string') {\n      return textEncoder.encode(body).length;\n    }\n\n    if (body instanceof URLSearchParams) {\n      return textEncoder.encode(body.toString()).length;\n    }\n\n    if (body instanceof FormData) {\n      const formDataStr = _serializeFormData(body);\n      return textEncoder.encode(formDataStr).length;\n    }\n\n    if (body instanceof Blob) {\n      return body.size;\n    }\n\n    if (body instanceof ArrayBuffer) {\n      return body.byteLength;\n    }\n\n    // Currently unhandled types: ArrayBufferView, ReadableStream\n  } catch (e) {\n    // just return undefined\n  }\n\n  return undefined;\n}\n\n/** Convert a Content-Length header to number/undefined.  */\nfunction parseContentLengthHeader(header) {\n  if (!header) {\n    return undefined;\n  }\n\n  const size = parseInt(header, 10);\n  return isNaN(size) ? undefined : size;\n}\n\n/** Get the string representation of a body. */\nfunction getBodyString(body) {\n  if (typeof body === 'string') {\n    return body;\n  }\n\n  if (body instanceof URLSearchParams) {\n    return body.toString();\n  }\n\n  if (body instanceof FormData) {\n    return _serializeFormData(body);\n  }\n\n  return undefined;\n}\n\n/** Convert ReplayNetworkRequestData to a PerformanceEntry. */\nfunction makeNetworkReplayBreadcrumb(\n  type,\n  data,\n) {\n  if (!data) {\n    return null;\n  }\n\n  const { startTimestamp, endTimestamp, url, method, statusCode, request, response } = data;\n\n  const result = {\n    type,\n    start: startTimestamp / 1000,\n    end: endTimestamp / 1000,\n    name: url,\n    data: dropUndefinedKeys({\n      method,\n      statusCode,\n      request,\n      response,\n    }),\n  };\n\n  return result;\n}\n\n/** Build the request or response part of a replay network breadcrumb that was skipped. */\nfunction buildSkippedNetworkRequestOrResponse(bodySize) {\n  return {\n    headers: {},\n    size: bodySize,\n    _meta: {\n      warnings: ['URL_SKIPPED'],\n    },\n  };\n}\n\n/** Build the request or response part of a replay network breadcrumb. */\nfunction buildNetworkRequestOrResponse(\n  headers,\n  bodySize,\n  body,\n) {\n  if (!bodySize && Object.keys(headers).length === 0) {\n    return undefined;\n  }\n\n  if (!bodySize) {\n    return {\n      headers,\n    };\n  }\n\n  if (!body) {\n    return {\n      headers,\n      size: bodySize,\n    };\n  }\n\n  const info = {\n    headers,\n    size: bodySize,\n  };\n\n  const { body: normalizedBody, warnings } = normalizeNetworkBody(body);\n  info.body = normalizedBody;\n  if (warnings && warnings.length > 0) {\n    info._meta = {\n      warnings,\n    };\n  }\n\n  return info;\n}\n\n/** Filter a set of headers */\nfunction getAllowedHeaders(headers, allowedHeaders) {\n  return Object.keys(headers).reduce((filteredHeaders, key) => {\n    const normalizedKey = key.toLowerCase();\n    // Avoid putting empty strings into the headers\n    if (allowedHeaders.includes(normalizedKey) && headers[key]) {\n      filteredHeaders[normalizedKey] = headers[key];\n    }\n    return filteredHeaders;\n  }, {});\n}\n\nfunction _serializeFormData(formData) {\n  // This is a bit simplified, but gives us a decent estimate\n  // This converts e.g. { name: 'Anne Smith', age: 13 } to 'name=Anne+Smith&age=13'\n  // @ts-expect-error passing FormData to URLSearchParams actually works\n  return new URLSearchParams(formData).toString();\n}\n\nfunction normalizeNetworkBody(body)\n\n {\n  if (!body || typeof body !== 'string') {\n    return {\n      body,\n    };\n  }\n\n  const exceedsSizeLimit = body.length > NETWORK_BODY_MAX_SIZE;\n\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 (e3) {\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 approriate).\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    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('[Replay] Failed to capture fetch breadcrumb', error);\n  }\n}\n\n/**\n * Enrich a breadcrumb with additional data.\n * This has to be sync & mutate the given breadcrumb,\n * as the breadcrumb is afterwards consumed by other handlers.\n */\nfunction enrichFetchBreadcrumb(\n  breadcrumb,\n  hint,\n  options,\n) {\n  const { input, response } = hint;\n\n  const body = _getFetchRequestArgBody(input);\n  const reqSize = getBodySize(body, options.textEncoder);\n\n  const resSize = response ? parseContentLengthHeader(response.headers.get('content-length')) : undefined;\n\n  if (reqSize !== undefined) {\n    breadcrumb.data.request_body_size = reqSize;\n  }\n  if (resSize !== undefined) {\n    breadcrumb.data.response_body_size = resSize;\n  }\n}\n\nasync function _prepareFetchData(\n  breadcrumb,\n  hint,\n  options\n\n,\n) {\n  const { startTimestamp, endTimestamp } = 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 = 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 = getBodyString(requestBody);\n  return buildNetworkRequestOrResponse(headers, requestBodySize, bodyStr);\n}\n\nasync function _getResponseInfo(\n  captureDetails,\n  {\n    networkCaptureBodies,\n    textEncoder,\n    networkResponseHeaders,\n  }\n\n,\n  response,\n  responseBodySize,\n) {\n  if (!captureDetails && responseBodySize !== undefined) {\n    return buildSkippedNetworkRequestOrResponse(responseBodySize);\n  }\n\n  const headers = getAllHeaders(response.headers, networkResponseHeaders);\n\n  if (!networkCaptureBodies && responseBodySize !== undefined) {\n    return buildNetworkRequestOrResponse(headers, responseBodySize, undefined);\n  }\n\n  // Only clone the response if we need to\n  try {\n    // We have to clone this, as the body can only be read once\n    const res = response.clone();\n    const bodyText = await _parseFetchBody(res);\n\n    const size =\n      bodyText && bodyText.length && responseBodySize === undefined\n        ? getBodySize(bodyText, textEncoder)\n        : responseBodySize;\n\n    if (!captureDetails) {\n      return buildSkippedNetworkRequestOrResponse(size);\n    }\n\n    if (networkCaptureBodies) {\n      return buildNetworkRequestOrResponse(headers, size, bodyText);\n    }\n\n    return buildNetworkRequestOrResponse(headers, size, undefined);\n  } catch (e) {\n    // fallback\n    return buildNetworkRequestOrResponse(headers, responseBodySize, undefined);\n  }\n}\n\nasync function _parseFetchBody(response) {\n  try {\n    return await response.text();\n  } catch (e2) {\n    return undefined;\n  }\n}\n\nfunction _getFetchRequestArgBody(fetchArgs = []) {\n  // We only support getting the body from the fetch options\n  if (fetchArgs.length !== 2 || typeof fetchArgs[1] !== 'object') {\n    return undefined;\n  }\n\n  return (fetchArgs[1] ).body;\n}\n\nfunction getAllHeaders(headers, allowedHeaders) {\n  const allHeaders = {};\n\n  allowedHeaders.forEach(header => {\n    if (headers.get(header)) {\n      allHeaders[header] = headers.get(header) ;\n    }\n  });\n\n  return allHeaders;\n}\n\nfunction getRequestHeaders(fetchArgs, allowedHeaders) {\n  if (fetchArgs.length === 1 && typeof fetchArgs[0] !== 'string') {\n    return getHeadersFromOptions(fetchArgs[0] , allowedHeaders);\n  }\n\n  if (fetchArgs.length === 2) {\n    return getHeadersFromOptions(fetchArgs[1] , allowedHeaders);\n  }\n\n  return {};\n}\n\nfunction getHeadersFromOptions(\n  input,\n  allowedHeaders,\n) {\n  if (!input) {\n    return {};\n  }\n\n  const headers = input.headers;\n\n  if (!headers) {\n    return {};\n  }\n\n  if (headers instanceof Headers) {\n    return getAllHeaders(headers, allowedHeaders);\n  }\n\n  // We do not support this, as it is not really documented (anymore?)\n  if (Array.isArray(headers)) {\n    return {};\n  }\n\n  return getAllowedHeaders(headers, allowedHeaders);\n}\n\n/**\n * Capture an XHR breadcrumb to a replay.\n * This adds additional data (where approriate).\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    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('[Replay] Failed to capture xhr breadcrumb', error);\n  }\n}\n\n/**\n * Enrich a breadcrumb with additional data.\n * This has to be sync & mutate the given breadcrumb,\n * as the breadcrumb is afterwards consumed by other handlers.\n */\nfunction enrichXhrBreadcrumb(\n  breadcrumb,\n  hint,\n  options,\n) {\n  const { xhr, input } = hint;\n\n  const reqSize = getBodySize(input, options.textEncoder);\n  const resSize = xhr.getResponseHeader('content-length')\n    ? parseContentLengthHeader(xhr.getResponseHeader('content-length'))\n    : getBodySize(xhr.response, options.textEncoder);\n\n  if (reqSize !== undefined) {\n    breadcrumb.data.request_body_size = reqSize;\n  }\n  if (resSize !== undefined) {\n    breadcrumb.data.response_body_size = resSize;\n  }\n}\n\nfunction _prepareXhrData(\n  breadcrumb,\n  hint,\n  options,\n) {\n  const { startTimestamp, endTimestamp, 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 (!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 request = buildNetworkRequestOrResponse(\n    networkRequestHeaders,\n    requestBodySize,\n    options.networkCaptureBodies ? getBodyString(input) : undefined,\n  );\n  const response = buildNetworkRequestOrResponse(\n    networkResponseHeaders,\n    responseBodySize,\n    options.networkCaptureBodies ? hint.xhr.responseText : undefined,\n  );\n\n  return {\n    startTimestamp,\n    endTimestamp,\n    url,\n    method,\n    statusCode,\n    request,\n    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    acc[key.toLowerCase()] = value;\n    return acc;\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 = getCurrentHub().getClient();\n\n  try {\n    const textEncoder = new TextEncoder();\n\n    const {\n      networkDetailAllowUrls,\n      networkDetailDenyUrls,\n      networkCaptureBodies,\n      networkRequestHeaders,\n      networkResponseHeaders,\n    } = replay.getOptions();\n\n    const options = {\n      replay,\n      textEncoder,\n      networkDetailAllowUrls,\n      networkDetailDenyUrls,\n      networkCaptureBodies,\n      networkRequestHeaders,\n      networkResponseHeaders,\n    };\n\n    if (client && client.on) {\n      client.on('beforeAddBreadcrumb', (breadcrumb, hint) => beforeAddNetworkBreadcrumb(options, breadcrumb, hint));\n    } else {\n      // Fallback behavior\n      addInstrumentationHandler('fetch', handleFetchSpanListener(replay));\n      addInstrumentationHandler('xhr', handleXhrSpanListener(replay));\n    }\n  } catch (e2) {\n    // Do nothing\n  }\n}\n\n/** just exported for tests */\nfunction beforeAddNetworkBreadcrumb(\n  options,\n  breadcrumb,\n  hint,\n) {\n  if (!breadcrumb.data) {\n    return;\n  }\n\n  try {\n    if (_isXhrBreadcrumb(breadcrumb) && _isXhrHint(hint)) {\n      // This has to be sync, as we need to ensure the breadcrumb is enriched in the same tick\n      // Because the hook runs synchronously, and the breadcrumb is afterwards passed on\n      // So any async mutations to it will not be reflected in the final breadcrumb\n      enrichXhrBreadcrumb(breadcrumb, hint, options);\n\n      void captureXhrBreadcrumbToReplay(breadcrumb, hint, options);\n    }\n\n    if (_isFetchBreadcrumb(breadcrumb) && _isFetchHint(hint)) {\n      // This has to be sync, as we need to ensure the breadcrumb is enriched in the same tick\n      // Because the hook runs synchronously, and the breadcrumb is afterwards passed on\n      // So any async mutations to it will not be reflected in the final breadcrumb\n      enrichFetchBreadcrumb(breadcrumb, hint, options);\n\n      void captureFetchBreadcrumbToReplay(breadcrumb, hint, options);\n    }\n  } catch (e) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('Error when enriching network breadcrumb');\n  }\n}\n\nfunction _isXhrBreadcrumb(breadcrumb) {\n  return breadcrumb.category === 'xhr';\n}\n\nfunction _isFetchBreadcrumb(breadcrumb) {\n  return breadcrumb.category === 'fetch';\n}\n\nfunction _isXhrHint(hint) {\n  return hint && hint.xhr;\n}\n\nfunction _isFetchHint(hint) {\n  return hint && hint.response;\n}\n\nlet _LAST_BREADCRUMB = null;\n\nfunction isBreadcrumbWithCategory(breadcrumb) {\n  return !!breadcrumb.category;\n}\n\nconst handleScopeListener =\n  (replay) =>\n  (scope) => {\n    if (!replay.isEnabled()) {\n      return;\n    }\n\n    const result = handleScope(scope);\n\n    if (!result) {\n      return;\n    }\n\n    addBreadcrumbEvent(replay, result);\n  };\n\n/**\n * An event handler to handle scope changes.\n */\nfunction handleScope(scope) {\n  // TODO (v8): Remove this guard. This was put in place because we introduced\n  // Scope.getLastBreadcrumb mid-v7 which caused incompatibilities with older SDKs.\n  // For now, we'll just return null if the method doesn't exist but we should eventually\n  // get rid of this guard.\n  const newBreadcrumb = scope.getLastBreadcrumb && scope.getLastBreadcrumb();\n\n  // Listener can be called when breadcrumbs have not changed, so we store the\n  // reference to the last crumb and only return a crumb if it has changed\n  if (_LAST_BREADCRUMB === newBreadcrumb || !newBreadcrumb) {\n    return null;\n  }\n\n  _LAST_BREADCRUMB = newBreadcrumb;\n\n  if (\n    !isBreadcrumbWithCategory(newBreadcrumb) ||\n    ['fetch', 'xhr', 'sentry.event', 'sentry.transaction'].includes(newBreadcrumb.category) ||\n    newBreadcrumb.category.startsWith('ui.')\n  ) {\n    return null;\n  }\n\n  if (newBreadcrumb.category === 'console') {\n    return normalizeConsoleBreadcrumb(newBreadcrumb);\n  }\n\n  return createBreadcrumb(newBreadcrumb);\n}\n\n/** exported for tests only */\nfunction normalizeConsoleBreadcrumb(\n  breadcrumb,\n) {\n  const args = breadcrumb.data && breadcrumb.data.arguments;\n\n  if (!Array.isArray(args) || args.length === 0) {\n    return createBreadcrumb(breadcrumb);\n  }\n\n  let isTruncated = false;\n\n  // Avoid giant args captures\n  const normalizedArgs = args.map(arg => {\n    if (!arg) {\n      return arg;\n    }\n    if (typeof arg === 'string') {\n      if (arg.length > CONSOLE_ARG_MAX_SIZE) {\n        isTruncated = true;\n        return `${arg.slice(0, CONSOLE_ARG_MAX_SIZE)}…`;\n      }\n\n      return arg;\n    }\n    if (typeof arg === 'object') {\n      try {\n        const normalizedArg = normalize(arg, 7);\n        const stringified = JSON.stringify(normalizedArg);\n        if (stringified.length > CONSOLE_ARG_MAX_SIZE) {\n          isTruncated = true;\n          // We use the pretty printed JSON string here as a base\n          return `${JSON.stringify(normalizedArg, null, 2).slice(0, CONSOLE_ARG_MAX_SIZE)}…`;\n        }\n        return normalizedArg;\n      } catch (e) {\n        // fall back to default\n      }\n    }\n\n    return arg;\n  });\n\n  return createBreadcrumb({\n    ...breadcrumb,\n    data: {\n      ...breadcrumb.data,\n      arguments: normalizedArgs,\n      ...(isTruncated ? { _meta: { warnings: ['CONSOLE_ARG_TRUNCATED'] } } : {}),\n    },\n  });\n}\n\n/**\n * Add global listeners that cannot be removed.\n */\nfunction addGlobalListeners(replay) {\n  // Listeners from core SDK //\n  const scope = getCurrentHub().getScope();\n  const client = getCurrentHub().getClient();\n\n  scope.addScopeListener(handleScopeListener(replay));\n  addInstrumentationHandler('dom', handleDomListener(replay));\n  addInstrumentationHandler('history', handleHistorySpanListener(replay));\n  handleNetworkBreadcrumbs(replay);\n\n  // Tag all (non replay) events that get sent to Sentry with the current\n  // replay ID so that we can reference them later in the UI\n  const eventProcessor = handleGlobalEventListener(replay, !hasHooks(client));\n  if (client && client.addEventProcessor) {\n    client.addEventProcessor(eventProcessor);\n  } else {\n    addGlobalEventProcessor(eventProcessor);\n  }\n\n  // If a custom client has no hooks yet, we continue to use the \"old\" implementation\n  if (hasHooks(client)) {\n    client.on('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('startTransaction', transaction => {\n      replay.lastTransaction = transaction;\n    });\n\n    // We may be missing the initial startTransaction due to timing issues,\n    // so we capture it on finish again.\n    client.on('finishTransaction', transaction => {\n      replay.lastTransaction = transaction;\n    });\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction hasHooks(client) {\n  return !!(client && client.on);\n}\n\n/**\n * Create a \"span\" for the total amount of memory being used by JS objects\n * (including v8 internal objects).\n */\nasync function addMemoryEntry(replay) {\n  // window.performance.memory is a non-standard API and doesn't work on all browsers, so we try-catch this\n  try {\n    return Promise.all(\n      createPerformanceSpans(replay, [\n        // @ts-expect-error memory doesn't exist on type Performance as the API is non-standard (we check that it exists above)\n        createMemoryEntry(WINDOW.performance.memory),\n      ]),\n    );\n  } catch (error) {\n    // Do nothing\n    return [];\n  }\n}\n\nfunction createMemoryEntry(memoryEntry) {\n  const { jsHeapSizeLimit, totalJSHeapSize, usedJSHeapSize } = memoryEntry;\n  // we don't want to use `getAbsoluteTime` because it adds the event time to the\n  // time origin, so we get the current timestamp instead\n  const time = Date.now() / 1000;\n  return {\n    type: 'memory',\n    name: 'memory',\n    start: time,\n    end: time,\n    data: {\n      memory: {\n        jsHeapSizeLimit,\n        totalJSHeapSize,\n        usedJSHeapSize,\n      },\n    },\n  };\n}\n\n/**\n * Heavily simplified debounce function based on lodash.debounce.\n *\n * This function takes a callback function (@param fun) and delays its invocation\n * by @param wait milliseconds. Optionally, a maxWait can be specified in @param options,\n * which ensures that the callback is invoked at least once after the specified max. wait time.\n *\n * @param func the function whose invocation is to be debounced\n * @param wait the minimum time until the function is invoked after it was called once\n * @param options the options object, which can contain the `maxWait` property\n *\n * @returns the debounced version of the function, which needs to be called at least once to start the\n *          debouncing process. Subsequent calls will reset the debouncing timer and, in case @paramfunc\n *          was already invoked in the meantime, return @param func's return value.\n *          The debounced function has two additional properties:\n *          - `flush`: Invokes the debounced function immediately and returns its return value\n *          - `cancel`: Cancels the debouncing process and resets the debouncing timer\n */\nfunction debounce(func, wait, options) {\n  let callbackReturnValue;\n\n  let timerId;\n  let maxTimerId;\n\n  const maxWait = options && options.maxWait ? Math.max(options.maxWait, wait) : 0;\n\n  function invokeFunc() {\n    cancelTimers();\n    callbackReturnValue = func();\n    return callbackReturnValue;\n  }\n\n  function cancelTimers() {\n    timerId !== undefined && clearTimeout(timerId);\n    maxTimerId !== undefined && clearTimeout(maxTimerId);\n    timerId = maxTimerId = undefined;\n  }\n\n  function flush() {\n    if (timerId !== undefined || maxTimerId !== undefined) {\n      return invokeFunc();\n    }\n    return callbackReturnValue;\n  }\n\n  function debounced() {\n    if (timerId) {\n      clearTimeout(timerId);\n    }\n    timerId = setTimeout(invokeFunc, wait);\n\n    if (maxWait && maxTimerId === undefined) {\n      maxTimerId = setTimeout(invokeFunc, maxWait);\n    }\n\n    return callbackReturnValue;\n  }\n\n  debounced.cancel = cancelTimers;\n  debounced.flush = flush;\n  return debounced;\n}\n\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      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.warn('[Replay] Received replay event after session expired.');\n\n      return;\n    }\n\n    // `_isCheckout` is only set when the checkout is due to `checkoutEveryNms`\n    // We also want to treat the first event as a checkout, so we handle this specifically here\n    const isCheckout = _isCheckout || !hadFirstEvent;\n    hadFirstEvent = true;\n\n    if (replay.clickDetector) {\n      updateClickDetectorForRecordingEvent(replay.clickDetector, event);\n    }\n\n    // The handler returns `true` if we do not want to trigger debounced flush, `false` if we want to debounce flush.\n    replay.addUpdate(() => {\n      // The session is always started immediately on pageload/init, but for\n      // error-only replays, it should reflect the most recent checkout\n      // when an error occurs. Clear any state that happens before this current\n      // checkout. This needs to happen before `addEvent()` which updates state\n      // dependent on this reset.\n      if (replay.recordingMode === 'buffer' && isCheckout) {\n        replay.setInitialState();\n      }\n\n      // If the event is not added (e.g. due to being paused, disabled, or out of the max replay duration),\n      // Skip all further steps\n      if (!addEventSync(replay, event, isCheckout)) {\n        // Return true to skip scheduling a debounced flush\n        return true;\n      }\n\n      // Different behavior for full snapshots (type=2), ignore other event types\n      // See https://github.com/rrweb-io/rrweb/blob/d8f9290ca496712aa1e7d472549480c4e7876594/packages/rrweb/src/types.ts#L16\n      if (!isCheckout) {\n        return false;\n      }\n\n      // Additionally, create a meta event that will capture certain SDK settings.\n      // In order to handle buffer mode, this needs to either be done when we\n      // receive checkout events or at flush time.\n      //\n      // `isCheckout` is always true, but want to be explicit that it should\n      // only be added for checkouts\n      addSettingsEvent(replay, isCheckout);\n\n      // If there is a previousSessionId after a full snapshot occurs, then\n      // the replay session was started due to session expiration. The new session\n      // is started before triggering a new checkout and contains the id\n      // of the previous session. Do not immediately flush in this case\n      // to avoid capturing only the checkout and instead the replay will\n      // be captured if they perform any follow-up actions.\n      if (replay.session && replay.session.previousSessionId) {\n        return true;\n      }\n\n      // When in buffer mode, make sure we adjust the session started date to the current earliest event of the buffer\n      // this should usually be the timestamp of the checkout event, but to be safe...\n      if (replay.recordingMode === 'buffer' && replay.session && replay.eventBuffer) {\n        const earliestEvent = replay.eventBuffer.getEarliestTimestamp();\n        if (earliestEvent) {\n          logInfo(\n            `[Replay] Updating session start time to earliest event in buffer to ${new Date(earliestEvent)}`,\n            replay.getOptions()._experiments.traceInternals,\n          );\n\n          replay.session.started = earliestEvent;\n\n          if (replay.getOptions().stickySession) {\n            saveSession(replay.session);\n          }\n        }\n      }\n\n      if (replay.recordingMode === 'session') {\n        // If the full snapshot is due to an initial load, we will not have\n        // a previous session ID. In this case, we want to buffer events\n        // for a set amount of time before flushing. This can help avoid\n        // capturing replays of users that immediately close the window.\n        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        sessionSampleRate: options.sessionSampleRate,\n        errorSampleRate: options.errorSampleRate,\n        useCompressionOption: options.useCompression,\n        blockAllMedia: options.blockAllMedia,\n        maskAllText: options.maskAllText,\n        maskAllInputs: options.maskAllInputs,\n        useCompression: replay.eventBuffer ? replay.eventBuffer.type === 'worker' : false,\n        networkDetailHasUrls: options.networkDetailAllowUrls.length > 0,\n        networkCaptureBodies: options.networkCaptureBodies,\n        networkRequestHasHeaders: options.networkRequestHeaders.length > 0,\n        networkResponseHasHeaders: options.networkResponseHeaders.length > 0,\n      },\n    },\n  };\n}\n\n/**\n * Add a \"meta\" event that contains a simplified view on current configuration\n * options. This should only be included on the first segment of a recording.\n */\nfunction addSettingsEvent(replay, isCheckout) {\n  // Only need to add this event when sending the first segment\n  if (!isCheckout || !replay.session || replay.session.segmentId !== 0) {\n    return;\n  }\n\n  addEventSync(replay, createOptionsEvent(replay), false);\n}\n\n/**\n * Create a replay envelope ready to be sent.\n * This includes both the replay event, as well as the recording data.\n */\nfunction createReplayEnvelope(\n  replayEvent,\n  recordingData,\n  dsn,\n  tunnel,\n) {\n  return createEnvelope(\n    createEventEnvelopeHeaders(replayEvent, getSdkMetadataForEnvelopeHeader(replayEvent), tunnel, dsn),\n    [\n      [{ type: 'replay_event' }, replayEvent],\n      [\n        {\n          type: 'replay_recording',\n          // If string then we need to encode to UTF8, otherwise will have\n          // wrong size. TextEncoder has similar browser support to\n          // MutationObserver, although it does not accept IE11.\n          length:\n            typeof recordingData === 'string' ? new TextEncoder().encode(recordingData).length : recordingData.length,\n        },\n        recordingData,\n      ],\n    ],\n  );\n}\n\n/**\n * Prepare the recording data ready to be sent.\n */\nfunction prepareRecordingData({\n  recordingData,\n  headers,\n}\n\n) {\n  let payloadWithSequence;\n\n  // XXX: newline is needed to separate sequence id from events\n  const replayHeaders = `${JSON.stringify(headers)}\n`;\n\n  if (typeof recordingData === 'string') {\n    payloadWithSequence = `${replayHeaders}${recordingData}`;\n  } else {\n    const enc = new TextEncoder();\n    // XXX: newline is needed to separate sequence id from events\n    const sequence = enc.encode(replayHeaders);\n    // Merge the two Uint8Arrays\n    payloadWithSequence = new Uint8Array(sequence.length + recordingData.length);\n    payloadWithSequence.set(sequence);\n    payloadWithSequence.set(recordingData, sequence.length);\n  }\n\n  return payloadWithSequence;\n}\n\n/**\n * Prepare a replay event & enrich it with the SDK metadata.\n */\nasync function prepareReplayEvent({\n  client,\n  scope,\n  replayId: event_id,\n  event,\n}\n\n) {\n  const integrations =\n    typeof client._integrations === 'object' && client._integrations !== null && !Array.isArray(client._integrations)\n      ? Object.keys(client._integrations)\n      : undefined;\n\n  const eventHint = { event_id, integrations };\n\n  if (client.emit) {\n    client.emit('preprocessEvent', event, eventHint);\n  }\n\n  const preparedEvent = (await prepareEvent(\n    client.getOptions(),\n    event,\n    eventHint,\n    scope,\n    client,\n  )) ;\n\n  // If e.g. a global event processor returned null\n  if (!preparedEvent) {\n    return null;\n  }\n\n  // This normally happens in browser client \"_prepareEvent\"\n  // but since we do not use this private method from the client, but rather the plain import\n  // we need to do this manually.\n  preparedEvent.platform = preparedEvent.platform || 'javascript';\n\n  // extract the SDK name because `client._prepareEvent` doesn't add it to the event\n  const metadata = client.getSdkMetadata && client.getSdkMetadata();\n  const { name, version } = (metadata && metadata.sdk) || {};\n\n  preparedEvent.sdk = {\n    ...preparedEvent.sdk,\n    name: name || 'sentry.javascript.unknown',\n    version: version || '0.0.0',\n  };\n\n  return preparedEvent;\n}\n\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 hub = getCurrentHub();\n  const client = hub.getClient();\n  const scope = hub.getScope();\n  const transport = client && client.getTransport();\n  const dsn = client && client.getDsn();\n\n  if (!client || !transport || !dsn || !session.sampled) {\n    return;\n  }\n\n  const baseEvent = {\n    type: REPLAY_EVENT_NAME,\n    replay_start_timestamp: initialTimestamp / 1000,\n    timestamp: timestamp / 1000,\n    error_ids: errorIds,\n    trace_ids: traceIds,\n    urls,\n    replay_id: replayId,\n    segment_id,\n    replay_type: session.sampled,\n  };\n\n  const replayEvent = await prepareReplayEvent({ scope, client, replayId, event: baseEvent });\n\n  if (!replayEvent) {\n    // Taken from baseclient's `_processEvent` method, where this is handled for errors/transactions\n    client.recordDroppedEvent('event_processor', 'replay', baseEvent);\n    logInfo('An event processor returned `null`, will not send event.');\n    return;\n  }\n\n  /*\n  For reference, the fully built event looks something like this:\n  {\n      \"type\": \"replay_event\",\n      \"timestamp\": 1670837008.634,\n      \"error_ids\": [\n          \"errorId\"\n      ],\n      \"trace_ids\": [\n          \"traceId\"\n      ],\n      \"urls\": [\n          \"https://example.com\"\n      ],\n      \"replay_id\": \"eventId\",\n      \"segment_id\": 3,\n      \"replay_type\": \"error\",\n      \"platform\": \"javascript\",\n      \"event_id\": \"eventId\",\n      \"environment\": \"production\",\n      \"sdk\": {\n          \"integrations\": [\n              \"BrowserTracing\",\n              \"Replay\"\n          ],\n          \"name\": \"sentry.javascript.browser\",\n          \"version\": \"7.25.0\"\n      },\n      \"sdkProcessingMetadata\": {},\n      \"contexts\": {\n      },\n  }\n  */\n\n  // Prevent this data (which, if it exists, was used in earlier steps in the processing pipeline) from being sent to\n  // sentry. (Note: Our use of this property comes and goes with whatever we might be debugging, whatever hacks we may\n  // have temporarily added, etc. Even if we don't happen to be using it at some point in the future, let's not get rid\n  // of this `delete`, lest we miss putting it back in the next time the property is in use.)\n  delete replayEvent.sdkProcessingMetadata;\n\n  const envelope = createReplayEnvelope(replayEvent, preparedRecordingData, dsn, client.getOptions().tunnel);\n\n  let response;\n\n  try {\n    response = await transport.send(envelope);\n  } catch (err) {\n    const error = new Error(UNABLE_TO_SEND_REPLAY);\n\n    try {\n      // In case browsers don't allow this property to be writable\n      // @ts-expect-error This needs lib es2022 and newer\n      error.cause = err;\n    } catch (e) {\n      // nothing to do\n    }\n    throw error;\n  }\n\n  // TODO (v8): we can remove this guard once transport.send's type signature doesn't include void anymore\n  if (!response) {\n    return response;\n  }\n\n  // If the status code is invalid, we want to immediately stop & not retry\n  if (typeof response.statusCode === 'number' && (response.statusCode < 200 || response.statusCode >= 300)) {\n    throw new TransportStatusCodeError(response.statusCode);\n  }\n\n  const rateLimits = updateRateLimits({}, response);\n  if (isRateLimited(rateLimits, 'replay')) {\n    throw new RateLimitError(rateLimits);\n  }\n\n  return response;\n}\n\n/**\n * This error indicates that the transport returned an invalid status code.\n */\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, options } = replayData;\n\n  // short circuit if there's no events to upload (this shouldn't happen as _runFlush makes this check)\n  if (!recordingData.length) {\n    return;\n  }\n\n  try {\n    await sendReplayRequest(replayData);\n    return true;\n  } catch (err) {\n    if (err instanceof TransportStatusCodeError || err instanceof RateLimitError) {\n      throw err;\n    }\n\n    // Capture error for every failed replay\n    setContext('Replays', {\n      _retryCount: retryConfig.count,\n    });\n\n    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && options._experiments && options._experiments.captureExceptions) {\n      captureException(err);\n    }\n\n    // If an error happened here, it's likely that uploading the attachment\n    // failed, we'll can retry with the same events payload\n    if (retryConfig.count >= RETRY_MAX_COUNT) {\n      const error = new Error(`${UNABLE_TO_SEND_REPLAY} - max retries exceeded`);\n\n      try {\n        // In case browsers don't allow this property to be writable\n        // @ts-expect-error This needs lib es2022 and newer\n        error.cause = err;\n      } catch (e) {\n        // nothing to do\n      }\n\n      throw error;\n    }\n\n    // will retry in intervals of 5, 10, 30\n    retryConfig.interval *= ++retryConfig.count;\n\n    return new Promise((resolve, reject) => {\n      setTimeout(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 three modes:\n   *   - session: Record the whole session, sending it continuously\n   *   - buffer: Always keep the last 60s of recording, requires:\n   *     - having replaysOnErrorSampleRate > 0 to capture replay when an error occurs\n   *     - or calling `flush()` to send the replay\n   */\n\n  /**\n   * The current or last active transcation.\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  /**\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   constructor({\n    options,\n    recordingOptions,\n  }\n\n) {ReplayContainer.prototype.__init.call(this);ReplayContainer.prototype.__init2.call(this);ReplayContainer.prototype.__init3.call(this);ReplayContainer.prototype.__init4.call(this);ReplayContainer.prototype.__init5.call(this);ReplayContainer.prototype.__init6.call(this);\n    this.eventBuffer = null;\n    this.performanceEntries = [];\n    this.replayPerformanceEntries = [];\n    this.recordingMode = 'session';\n    this.timeouts = {\n      sessionIdlePause: SESSION_IDLE_PAUSE_DURATION,\n      sessionIdleExpire: SESSION_IDLE_EXPIRE_DURATION,\n    } ;\n    this._lastActivity = Date.now();\n    this._isEnabled = false;\n    this._isPaused = false;\n    this._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\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  /** Get the replay integration options. */\n   getOptions() {\n    return this._options;\n  }\n\n  /**\n   * Initializes the plugin based on sampling configuration. Should not be\n   * called outside of constructor.\n   */\n   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    if (errorSampleRate <= 0 && sessionSampleRate <= 0) {\n      return;\n    }\n\n    // Otherwise if there is _any_ sample rate set, try to load an existing\n    // session, or create a new one.\n    this._initializeSessionForSampling(previousSessionId);\n\n    if (!this.session) {\n      // This should not happen, something wrong has occurred\n      this._handleException(new Error('Unable to initialize and create session'));\n      return;\n    }\n\n    if (this.session.sampled === false) {\n      // This should only occur if `errorSampleRate` is 0 and was unsampled for\n      // session-based replay. In this case there is nothing to do.\n      return;\n    }\n\n    // If segmentId > 0, it means we've previously already captured this session\n    // In this case, we still want to continue in `session` recording mode\n    this.recordingMode = this.session.sampled === 'buffer' && this.session.segmentId === 0 ? 'buffer' : 'session';\n\n    logInfoNextTick(\n      `[Replay] Starting replay in ${this.recordingMode} mode`,\n      this._options._experiments.traceInternals,\n    );\n\n    this._initializeRecording();\n  }\n\n  /**\n   * Start a replay regardless of sampling rate. Calling this will always\n   * create a new session. Will throw an error if replay is already in progress.\n   *\n   * Creates or loads a session, attaches listeners to varying events (DOM,\n   * _performanceObserver, Recording, Sentry SDK, etc)\n   */\n   start() {\n    if (this._isEnabled && this.recordingMode === 'session') {\n      throw new Error('Replay recording is already in progress');\n    }\n\n    if (this._isEnabled && this.recordingMode === 'buffer') {\n      throw new Error('Replay buffering is in progress, call `flush()` to save the replay');\n    }\n\n    logInfoNextTick('[Replay] Starting replay in session mode', this._options._experiments.traceInternals);\n\n    const session = loadOrCreateSession(\n      {\n        maxReplayDuration: this._options.maxReplayDuration,\n        sessionIdleExpire: this.timeouts.sessionIdleExpire,\n        traceInternals: this._options._experiments.traceInternals,\n      },\n      {\n        stickySession: this._options.stickySession,\n        // This is intentional: create a new session-based replay when calling `start()`\n        sessionSampleRate: 1,\n        allowBuffering: false,\n      },\n    );\n\n    this.session = session;\n\n    this._initializeRecording();\n  }\n\n  /**\n   * Start replay buffering. Buffers until `flush()` is called or, if\n   * `replaysOnErrorSampleRate` > 0, an error occurs.\n   */\n   startBuffering() {\n    if (this._isEnabled) {\n      throw new Error('Replay recording is already in progress');\n    }\n\n    logInfoNextTick('[Replay] Starting replay in buffer mode', this._options._experiments.traceInternals);\n\n    const session = loadOrCreateSession(\n      {\n        sessionIdleExpire: this.timeouts.sessionIdleExpire,\n        maxReplayDuration: this._options.maxReplayDuration,\n        traceInternals: this._options._experiments.traceInternals,\n      },\n      {\n        stickySession: this._options.stickySession,\n        sessionSampleRate: 0,\n        allowBuffering: true,\n      },\n    );\n\n    this.session = session;\n\n    this.recordingMode = 'buffer';\n    this._initializeRecording();\n  }\n\n  /**\n   * Start recording.\n   *\n   * Note that this will cause a new DOM checkout\n   */\n   startRecording() {\n    try {\n      this._stopRecording = record({\n        ...this._recordingOptions,\n        // When running in error sampling mode, we need to overwrite `checkoutEveryNms`\n        // Without this, it would record forever, until an error happens, which we don't want\n        // instead, we'll always keep the last 60 seconds of replay before an error happened\n        ...(this.recordingMode === 'buffer' && { checkoutEveryNms: BUFFER_CHECKOUT_TIME }),\n        emit: getHandleRecordingEmit(this),\n        onMutation: this._onMutationHandler,\n      });\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      logInfo(\n        `[Replay] Stopping Replay${reason ? ` triggered by ${reason}` : ''}`,\n        this._options._experiments.traceInternals,\n      );\n\n      this._removeListeners();\n      this.stopRecording();\n\n      this._debouncedFlush.cancel();\n      // See comment above re: `_isEnabled`, we \"force\" a flush, ignoring the\n      // `_isEnabled` state of the plugin since it was disabled above.\n      if (forceFlush) {\n        await this._flush({ force: true });\n      }\n\n      // After flush, destroy event buffer\n      this.eventBuffer && this.eventBuffer.destroy();\n      this.eventBuffer = null;\n\n      // Clear session from session storage, note this means if a new session\n      // is started after, it will not have `previousSessionId`\n      clearSession(this);\n    } catch (err) {\n      this._handleException(err);\n    }\n  }\n\n  /**\n   * Pause some replay functionality. See comments for `_isPaused`.\n   * This differs from stop as this only stops DOM recording, it is\n   * not as thorough of a shutdown as `stop()`.\n   */\n   pause() {\n    if (this._isPaused) {\n      return;\n    }\n\n    this._isPaused = true;\n    this.stopRecording();\n\n    logInfo('[Replay] Pausing replay', this._options._experiments.traceInternals);\n  }\n\n  /**\n   * Resumes recording, see notes for `pause().\n   *\n   * Note that calling `startRecording()` here will cause a\n   * new DOM checkout.`\n   */\n   resume() {\n    if (!this._isPaused || !this._checkSession()) {\n      return;\n    }\n\n    this._isPaused = false;\n    this.startRecording();\n\n    logInfo('[Replay] Resuming replay', this._options._experiments.traceInternals);\n  }\n\n  /**\n   * If not in \"session\" recording mode, flush event buffer which will create a new replay.\n   * Unless `continueRecording` is false, the replay will continue to record and\n   * behave as a \"session\"-based replay.\n   *\n   * Otherwise, queue up a flush.\n   */\n   async sendBufferedReplayOrFlush({ continueRecording = true } = {}) {\n    if (this.recordingMode === 'session') {\n      return this.flushImmediate();\n    }\n\n    const activityTime = Date.now();\n\n    logInfo('[Replay] Converting buffer to session', this._options._experiments.traceInternals);\n\n    // Allow flush to complete before resuming as a session recording, otherwise\n    // the checkout from `startRecording` may be included in the payload.\n    // Prefer to keep the error replay as a separate (and smaller) segment\n    // than the session replay.\n    await this.flushImmediate();\n\n    const hasStoppedRecording = this.stopRecording();\n\n    if (!continueRecording || !hasStoppedRecording) {\n      return;\n    }\n\n    // To avoid race conditions where this is called multiple times, we check here again that we are still buffering\n    if ((this.recordingMode ) === '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 mulitple 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 sesion (=replay) ID */\n   getSessionId() {\n    return this.session && this.session.id;\n  }\n\n  /**\n   * Checks if recording should be stopped due to user inactivity. Otherwise\n   * check if session is expired and create a new session if so. Triggers a new\n   * full snapshot on new session.\n   *\n   * Returns true if session is not expired, false otherwise.\n   * @hidden\n   */\n   checkAndHandleExpiredSession() {\n    // Prevent starting a new session if the last user activity is older than\n    // SESSION_IDLE_PAUSE_DURATION. Otherwise non-user activity can trigger a new\n    // session+recording. This creates noisy replays that do not have much\n    // content in them.\n    if (\n      this._lastActivity &&\n      isExpired(this._lastActivity, this.timeouts.sessionIdlePause) &&\n      this.session &&\n      this.session.sampled === 'session'\n    ) {\n      // Pause recording only for session-based replays. Otherwise, resuming\n      // will create a new replay and will conflict with users who only choose\n      // to record error-based replays only. (e.g. the resumed replay will not\n      // contain a reference to an error)\n      this.pause();\n      return;\n    }\n\n    // --- There is recent user activity --- //\n    // This will create a new session if expired, based on expiry length\n    if (!this._checkSession()) {\n      // Check session handles the refreshing itself\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Capture some initial state that can change throughout the lifespan of the\n   * replay. This is required because otherwise they would be captured at the\n   * first flush.\n   */\n   setInitialState() {\n    const urlPath = `${WINDOW.location.pathname}${WINDOW.location.hash}${WINDOW.location.search}`;\n    const url = `${WINDOW.location.origin}${urlPath}`;\n\n    this.performanceEntries = [];\n    this.replayPerformanceEntries = [];\n\n    // Reset _context as well\n    this._clearContext();\n\n    this._context.initialUrl = url;\n    this._context.initialTimestamp = Date.now();\n    this._context.urls.push(url);\n  }\n\n  /**\n   * Add a breadcrumb event, that may be throttled.\n   * If it was throttled, we add a custom breadcrumb to indicate that.\n   */\n   throttledAddEvent(\n    event,\n    isCheckout,\n  ) {\n    const res = this._throttledAddEvent(event, isCheckout);\n\n    // If this is THROTTLED, it means we have throttled the event for the first time\n    // In this case, we want to add a breadcrumb indicating that something was skipped\n    if (res === THROTTLED) {\n      const breadcrumb = createBreadcrumb({\n        category: 'replay.throttled',\n      });\n\n      this.addUpdate(() => {\n        // Return `false` if the event _was_ added, as that means we schedule a flush\n        return !addEventSync(this, {\n          type: ReplayEventTypeCustom,\n          timestamp: breadcrumb.timestamp || 0,\n          data: {\n            tag: 'breadcrumb',\n            payload: breadcrumb,\n            metric: true,\n          },\n        });\n      });\n    }\n\n    return res;\n  }\n\n  /**\n   * This will get the parametrized route name of the current page.\n   * This is only available if performance is enabled, and if an instrumented router is used.\n   */\n   getCurrentRoute() {\n    const lastTransaction = this.lastTransaction || getCurrentHub().getScope().getTransaction();\n    if (!lastTransaction || !['route', 'custom'].includes(lastTransaction.metadata.source)) {\n      return undefined;\n    }\n\n    return lastTransaction.name;\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  /** A wrapper to conditionally capture exceptions. */\n   _handleException(error) {\n    (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('[Replay]', error);\n\n    if ((typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && this._options._experiments && this._options._experiments.captureExceptions) {\n      captureException(error);\n    }\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        traceInternals: this._options._experiments.traceInternals,\n        previousSessionId,\n      },\n      {\n        stickySession: this._options.stickySession,\n        sessionSampleRate: this._options.sessionSampleRate,\n        allowBuffering,\n      },\n    );\n\n    this.session = session;\n  }\n\n  /**\n   * Checks and potentially refreshes the current session.\n   * Returns false if session is not recorded.\n   */\n   _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      void this._refreshSession(currentSession);\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Refresh a session with a new one.\n   * This stops the current session (without forcing a flush, as that would never work since we are expired),\n   * and then does a new sampling based on the refreshed session.\n   */\n   async _refreshSession(session) {\n    if (!this._isEnabled) {\n      return;\n    }\n    await this.stop({ reason: 'refresh session' });\n    this.initializeSampling(session.id);\n  }\n\n  /**\n   * Adds listeners to record events for the replay\n   */\n   _addListeners() {\n    try {\n      WINDOW.document.addEventListener('visibilitychange', this._handleVisibilityChange);\n      WINDOW.addEventListener('blur', this._handleWindowBlur);\n      WINDOW.addEventListener('focus', this._handleWindowFocus);\n      WINDOW.addEventListener('keydown', this._handleKeyboardEvent);\n\n      if (this.clickDetector) {\n        this.clickDetector.addListeners();\n      }\n\n      // There is no way to remove these listeners, so ensure they are only added once\n      if (!this._hasInitializedCoreListeners) {\n        addGlobalListeners(this);\n\n        this._hasInitializedCoreListeners = true;\n      }\n    } catch (err) {\n      this._handleException(err);\n    }\n\n    this._performanceCleanupCallback = setupPerformanceObserver(this);\n  }\n\n  /**\n   * Cleans up listeners that were created in `_addListeners`\n   */\n   _removeListeners() {\n    try {\n      WINDOW.document.removeEventListener('visibilitychange', this._handleVisibilityChange);\n\n      WINDOW.removeEventListener('blur', this._handleWindowBlur);\n      WINDOW.removeEventListener('focus', this._handleWindowFocus);\n      WINDOW.removeEventListener('keydown', this._handleKeyboardEvent);\n\n      if (this.clickDetector) {\n        this.clickDetector.removeListeners();\n      }\n\n      if (this._performanceCleanupCallback) {\n        this._performanceCleanupCallback();\n      }\n    } catch (err) {\n      this._handleException(err);\n    }\n  }\n\n  /**\n   * Handle when visibility of the page content changes. Opening a new tab will\n   * cause the state to change to hidden because of content of current page will\n   * be hidden. Likewise, moving a different window to cover the contents of the\n   * page will also trigger a change to a hidden state.\n   */\n   __init() {this._handleVisibilityChange = () => {\n    if (WINDOW.document.visibilityState === 'visible') {\n      this._doChangeToForegroundTasks();\n    } else {\n      this._doChangeToBackgroundTasks();\n    }\n  };}\n\n  /**\n   * Handle when page is blurred\n   */\n   __init2() {this._handleWindowBlur = () => {\n    const breadcrumb = createBreadcrumb({\n      category: 'ui.blur',\n    });\n\n    // Do not count blur as a user action -- it's part of the process of them\n    // leaving the page\n    this._doChangeToBackgroundTasks(breadcrumb);\n  };}\n\n  /**\n   * Handle when page is focused\n   */\n   __init3() {this._handleWindowFocus = () => {\n    const breadcrumb = createBreadcrumb({\n      category: 'ui.focus',\n    });\n\n    // Do not count focus as a user action -- instead wait until they focus and\n    // interactive with page\n    this._doChangeToForegroundTasks(breadcrumb);\n  };}\n\n  /** Ensure page remains active when a key is pressed. */\n   __init4() {this._handleKeyboardEvent = (event) => {\n    handleKeyboardEvent(this, event);\n  };}\n\n  /**\n   * Tasks to run when we consider a page to be hidden (via blurring and/or visibility)\n   */\n   _doChangeToBackgroundTasks(breadcrumb) {\n    if (!this.session) {\n      return;\n    }\n\n    const expired = isSessionExpired(this.session, {\n      maxReplayDuration: this._options.maxReplayDuration,\n      sessionIdleExpire: this.timeouts.sessionIdleExpire,\n    });\n\n    if (expired) {\n      return;\n    }\n\n    if (breadcrumb) {\n      this._createCustomBreadcrumb(breadcrumb);\n    }\n\n    // Send replay when the page/tab becomes hidden. There is no reason to send\n    // replay if it becomes visible, since no actions we care about were done\n    // while it was hidden\n    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      logInfo('[Replay] Document has become active, but session has expired');\n      return;\n    }\n\n    if (breadcrumb) {\n      this._createCustomBreadcrumb(breadcrumb);\n    }\n  }\n\n  /**\n   * Update user activity (across session lifespans)\n   */\n   _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      void 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    const performanceEntries = createPerformanceEntries(this.performanceEntries).concat(this.replayPerformanceEntries);\n\n    this.performanceEntries = [];\n    this.replayPerformanceEntries = [];\n\n    return Promise.all(createPerformanceSpans(this, performanceEntries));\n  }\n\n  /**\n   * Clear _context\n   */\n   _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 (!session || !eventBuffer) {\n      return;\n    }\n\n    // we only ever update this on the initial segment\n    if (session.segmentId) {\n      return;\n    }\n\n    const earliestEvent = eventBuffer.getEarliestTimestamp();\n    if (earliestEvent && earliestEvent < this._context.initialTimestamp) {\n      this._context.initialTimestamp = earliestEvent;\n    }\n  }\n\n  /**\n   * Return and clear _context\n   */\n   _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      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('[Replay] No session or eventBuffer found to flush.');\n      return;\n    }\n\n    await this._addPerformanceEntries();\n\n    // Check eventBuffer again, as it could have been stopped in the meanwhile\n    if (!this.eventBuffer || !this.eventBuffer.hasEvents) {\n      return;\n    }\n\n    // Only attach memory event if eventBuffer is not empty\n    await addMemoryEntry(this);\n\n    // Check eventBuffer again, as it could have been stopped in the meanwhile\n    if (!this.eventBuffer) {\n      return;\n    }\n\n    // if this changed in the meanwhile, e.g. because the session was refreshed or similar, we abort here\n    if (replayId !== this.getSessionId()) {\n      return;\n    }\n\n    try {\n      // This uses the data from the eventBuffer, so we need to call this before `finish()\n      this._updateInitialTimestampFromEventBuffer();\n\n      const timestamp = Date.now();\n\n      // Check total duration again, to avoid sending outdated stuff\n      // We leave 30s wiggle room to accomodate late flushing etc.\n      // This _could_ happen when the browser is suspended during flushing, in which case we just want to stop\n      if (timestamp - this._context.initialTimestamp > this._options.maxReplayDuration + 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        options: this.getOptions(),\n        timestamp,\n      });\n    } catch (err) {\n      this._handleException(err);\n\n      // This means we retried 3 times and all of them failed,\n      // or we ran into a problem we don't want to retry, like rate limiting.\n      // In this case, we want to completely stop the replay - otherwise, we may get inconsistent segments\n      void this.stop({ reason: 'sendReplay' });\n\n      const client = getCurrentHub().getClient();\n\n      if (client) {\n        client.recordDroppedEvent('send_error', 'replay');\n      }\n    }\n  }\n\n  /**\n   * Flush recording data to Sentry. Creates a lock so that only a single flush\n   * can be active at a time. Do not call this directly.\n   */\n   __init5() {this._flush = async ({\n    force = false,\n  }\n\n = {}) => {\n    if (!this._isEnabled && !force) {\n      // This can happen if e.g. the replay was stopped because of exceeding the retry limit\n      return;\n    }\n\n    if (!this.checkAndHandleExpiredSession()) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error('[Replay] Attempting to finish replay event after session expired.');\n      return;\n    }\n\n    if (!this.session) {\n      // should never happen, as we would have bailed out before\n      return;\n    }\n\n    const start = this.session.started;\n    const now = Date.now();\n    const duration = now - start;\n\n    // A flush is about to happen, cancel any queued flushes\n    this._debouncedFlush.cancel();\n\n    // If session is too short, or too long (allow some wiggle room over maxReplayDuration), do not send it\n    // This _should_ not happen, but it may happen if flush is triggered due to a page activity change or similar\n    const tooShort = duration < this._options.minReplayDuration;\n    const tooLong = duration > this._options.maxReplayDuration + 5000;\n    if (tooShort || tooLong) {\n      logInfo(\n        `[Replay] Session duration (${Math.floor(duration / 1000)}s) is too ${\n          tooShort ? 'short' : 'long'\n        }, not sending replay.`,\n        this._options._experiments.traceInternals,\n      );\n\n      if (tooShort) {\n        this._debouncedFlush();\n      }\n      return;\n    }\n\n    const eventBuffer = this.eventBuffer;\n    if (eventBuffer && this.session.segmentId === 0 && !eventBuffer.hasCheckout) {\n      logInfo('[Replay] Flushing initial segment without checkout.', this._options._experiments.traceInternals);\n      // TODO FN: Evaluate if we want to stop here, or remove this again?\n    }\n\n    // this._flushLock acts as a lock so that future calls to `_flush()`\n    // will be blocked until this promise resolves\n    if (!this._flushLock) {\n      this._flushLock = this._runFlush();\n      await this._flushLock;\n      this._flushLock = undefined;\n      return;\n    }\n\n    // Wait for previous flush to finish, then call the debounced `_flush()`.\n    // It's possible there are other flush requests queued and waiting for it\n    // to resolve. We want to reduce all outstanding requests (as well as any\n    // new flush requests that occur within a second of the locked flush\n    // completing) into a single flush.\n\n    try {\n      await this._flushLock;\n    } catch (err) {\n      (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__) && logger.error(err);\n    } finally {\n      this._debouncedFlush();\n    }\n  };}\n\n  /** Save the session, if it is sticky */\n   _maybeSaveSession() {\n    if (this.session && this._options.stickySession) {\n      saveSession(this.session);\n    }\n  }\n\n  /** Handler for rrweb.record.onMutation */\n   __init6() {this._onMutationHandler = (mutations) => {\n    const count = mutations.length;\n\n    const mutationLimit = this._options.mutationLimit;\n    const mutationBreadcrumbLimit = this._options.mutationBreadcrumbLimit;\n    const overMutationLimit = mutationLimit && count > mutationLimit;\n\n    // Create a breadcrumb if a lot of mutations happen at the same time\n    // We can show this in the UI as an information with potential performance improvements\n    if (count > mutationBreadcrumbLimit || overMutationLimit) {\n      const breadcrumb = createBreadcrumb({\n        category: 'replay.mutations',\n        data: {\n          count,\n          limit: overMutationLimit,\n        },\n      });\n      this._createCustomBreadcrumb(breadcrumb);\n    }\n\n    // Stop replay if over the mutation limit\n    if (overMutationLimit) {\n      void 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(\n  selectors,\n  defaultSelectors,\n  deprecatedClassOption,\n  deprecatedSelectorOption,\n) {\n  const deprecatedSelectors = typeof deprecatedSelectorOption === 'string' ? deprecatedSelectorOption.split(',') : [];\n\n  const allSelectors = [\n    ...selectors,\n    // @deprecated\n    ...deprecatedSelectors,\n\n    // sentry defaults\n    ...defaultSelectors,\n  ];\n\n  // @deprecated\n  if (typeof deprecatedClassOption !== 'undefined') {\n    // NOTE: No support for RegExp\n    if (typeof deprecatedClassOption === 'string') {\n      allSelectors.push(`.${deprecatedClassOption}`);\n    }\n\n    // eslint-disable-next-line no-console\n    console.warn(\n      '[Replay] You are using a deprecated configuration item for privacy. Read the documentation on how to use the new privacy configuration.',\n    );\n  }\n\n  return allSelectors.join(',');\n}\n\n/**\n * Returns privacy related configuration for use in rrweb\n */\nfunction getPrivacyOptions({\n  mask,\n  unmask,\n  block,\n  unblock,\n  ignore,\n\n  // eslint-disable-next-line deprecation/deprecation\n  blockClass,\n  // eslint-disable-next-line deprecation/deprecation\n  blockSelector,\n  // eslint-disable-next-line deprecation/deprecation\n  maskTextClass,\n  // eslint-disable-next-line deprecation/deprecation\n  maskTextSelector,\n  // eslint-disable-next-line deprecation/deprecation\n  ignoreClass,\n}) {\n  const defaultBlockedElements = ['base[href=\"/\"]'];\n\n  const maskSelector = getOption(mask, ['.sentry-mask', '[data-sentry-mask]'], maskTextClass, maskTextSelector);\n  const unmaskSelector = getOption(unmask, ['.sentry-unmask', '[data-sentry-unmask]']);\n\n  const options = {\n    // We are making the decision to make text and input selectors the same\n    maskTextSelector: maskSelector,\n    unmaskTextSelector: unmaskSelector,\n\n    blockSelector: getOption(\n      block,\n      ['.sentry-block', '[data-sentry-block]', ...defaultBlockedElements],\n      blockClass,\n      blockSelector,\n    ),\n    unblockSelector: getOption(unblock, ['.sentry-unblock', '[data-sentry-unblock]']),\n    ignoreSelector: getOption(ignore, ['.sentry-ignore', '[data-sentry-ignore]', 'input[type=\"file\"]'], ignoreClass),\n  };\n\n  if (blockClass instanceof RegExp) {\n    options.blockClass = blockClass;\n  }\n\n  if (maskTextClass instanceof RegExp) {\n    options.maskTextClass = maskTextClass;\n  }\n\n  return options;\n}\n\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 precendence\n  if (privacyOptions.unmaskTextSelector && el.matches(privacyOptions.unmaskTextSelector)) {\n    return value;\n  }\n\n  if (\n    maskAttributes.includes(key) ||\n    // Need to mask `value` attribute for `<input>` if it's a button-like\n    // type\n    (key === 'value' && el.tagName === 'INPUT' && ['submit', 'button'].includes(el.getAttribute('type') || ''))\n  ) {\n    return value.replace(/[\\S]/g, '*');\n  }\n\n  return value;\n}\n\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 * The main replay integration class, to be passed to `init({  integrations: [] })`.\n */\nclass Replay  {\n  /**\n   * @inheritDoc\n   */\n   static __initStatic() {this.id = 'Replay';}\n\n  /**\n   * @inheritDoc\n   */\n\n  /**\n   * Options to pass to `rrweb.record()`\n   */\n\n  /**\n   * Initial options passed to the replay integration, merged with default values.\n   * Note: `sessionSampleRate` and `errorSampleRate` are not required here, as they\n   * can only be finally set when setupOnce() is called.\n   *\n   * @private\n   */\n\n   constructor({\n    flushMinDelay = DEFAULT_FLUSH_MIN_DELAY,\n    flushMaxDelay = DEFAULT_FLUSH_MAX_DELAY,\n    minReplayDuration = MIN_REPLAY_DURATION,\n    maxReplayDuration = MAX_REPLAY_DURATION,\n    stickySession = true,\n    useCompression = true,\n    workerUrl,\n    _experiments = {},\n    sessionSampleRate,\n    errorSampleRate,\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\n    // eslint-disable-next-line deprecation/deprecation\n    blockClass,\n    // eslint-disable-next-line deprecation/deprecation\n    blockSelector,\n    // eslint-disable-next-line deprecation/deprecation\n    maskInputOptions,\n    // eslint-disable-next-line deprecation/deprecation\n    maskTextClass,\n    // eslint-disable-next-line deprecation/deprecation\n    maskTextSelector,\n    // eslint-disable-next-line deprecation/deprecation\n    ignoreClass,\n  } = {}) {\n    this.name = Replay.id;\n\n    const privacyOptions = getPrivacyOptions({\n      mask,\n      unmask,\n      block,\n      unblock,\n      ignore,\n      blockClass,\n      blockSelector,\n      maskTextClass,\n      maskTextSelector,\n      ignoreClass,\n    });\n\n    this._recordingOptions = {\n      maskAllInputs,\n      maskAllText,\n      maskInputOptions: { ...(maskInputOptions || {}), password: true },\n      maskTextFn: maskFn,\n      maskInputFn: maskFn,\n      maskAttributeFn: (key, 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      sessionSampleRate,\n      errorSampleRate,\n      useCompression,\n      workerUrl,\n      blockAllMedia,\n      maskAllInputs,\n      maskAllText,\n      mutationBreadcrumbLimit,\n      mutationLimit,\n      slowClickTimeout,\n      slowClickIgnoreSelectors,\n      networkDetailAllowUrls,\n      networkDetailDenyUrls,\n      networkCaptureBodies,\n      networkRequestHeaders: _getMergedNetworkHeaders(networkRequestHeaders),\n      networkResponseHeaders: _getMergedNetworkHeaders(networkResponseHeaders),\n      beforeAddRecordingEvent,\n      beforeErrorSampling,\n\n      _experiments,\n    };\n\n    if (typeof sessionSampleRate === 'number') {\n      // eslint-disable-next-line\n      console.warn(\n        `[Replay] You are passing \\`sessionSampleRate\\` to the Replay integration.\nThis option is deprecated and will be removed soon.\nInstead, configure \\`replaysSessionSampleRate\\` directly in the SDK init options, e.g.:\nSentry.init({ replaysSessionSampleRate: ${sessionSampleRate} })`,\n      );\n\n      this._initialOptions.sessionSampleRate = sessionSampleRate;\n    }\n\n    if (typeof errorSampleRate === 'number') {\n      // eslint-disable-next-line\n      console.warn(\n        `[Replay] You are passing \\`errorSampleRate\\` to the Replay integration.\nThis option is deprecated and will be removed soon.\nInstead, configure \\`replaysOnErrorSampleRate\\` directly in the SDK init options, e.g.:\nSentry.init({ replaysOnErrorSampleRate: ${errorSampleRate} })`,\n      );\n\n      this._initialOptions.errorSampleRate = errorSampleRate;\n    }\n\n    if (this._initialOptions.blockAllMedia) {\n      // `blockAllMedia` is a more user friendly option to configure blocking\n      // embedded media elements\n      this._recordingOptions.blockSelector = !this._recordingOptions.blockSelector\n        ? MEDIA_SELECTORS\n        : `${this._recordingOptions.blockSelector},${MEDIA_SELECTORS}`;\n    }\n\n    if (this._isInitialized && isBrowser()) {\n      throw new Error('Multiple Sentry Session Replay instances are not supported');\n    }\n\n    this._isInitialized = true;\n  }\n\n  /** If replay has already been initialized */\n   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   setupOnce() {\n    if (!isBrowser()) {\n      return;\n    }\n\n    this._setup();\n\n    // Once upon a time, we tried to create a transaction in `setupOnce` and it would\n    // potentially create a transaction before some native SDK integrations have run\n    // and applied their own global event processor. An example is:\n    // https://github.com/getsentry/sentry-javascript/blob/b47ceafbdac7f8b99093ce6023726ad4687edc48/packages/browser/src/integrations/useragent.ts\n    //\n    // So we call `this._initialize()` in next event loop as a workaround to wait for other\n    // global event processors to finish. This is no longer needed, but keeping it\n    // here to avoid any future issues.\n    setTimeout(() => this._initialize());\n  }\n\n  /**\n   * Start a replay regardless of sampling rate. Calling this will always\n   * create a new session. Will throw an error if replay is already in progress.\n   *\n   * Creates or loads a session, attaches listeners to varying events (DOM,\n   * PerformanceObserver, Recording, Sentry SDK, etc)\n   */\n   start() {\n    if (!this._replay) {\n      return;\n    }\n\n    this._replay.start();\n  }\n\n  /**\n   * Start replay buffering. Buffers until `flush()` is called or, if\n   * `replaysOnErrorSampleRate` > 0, until an error occurs.\n   */\n   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   * 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 || !this._replay.isEnabled()) {\n      return Promise.resolve();\n    }\n\n    return this._replay.sendBufferedReplayOrFlush(options);\n  }\n\n  /**\n   * Get the current session ID.\n   */\n   getReplayId() {\n    if (!this._replay || !this._replay.isEnabled()) {\n      return;\n    }\n\n    return this._replay.getSessionId();\n  }\n  /**\n   * Initializes replay.\n   */\n   _initialize() {\n    if (!this._replay) {\n      return;\n    }\n\n    this._replay.initializeSampling();\n  }\n\n  /** Setup the integration. */\n   _setup() {\n    // Client is not available in constructor, so we need to wait until setupOnce\n    const finalOptions = loadReplayOptionsFromClient(this._initialOptions);\n\n    this._replay = new ReplayContainer({\n      options: finalOptions,\n      recordingOptions: this._recordingOptions,\n    });\n  }\n} Replay.__initStatic();\n\n/** Parse Replay-related options from SDK options */\nfunction loadReplayOptionsFromClient(initialOptions) {\n  const client = getCurrentHub().getClient();\n  const opt = client && (client.getOptions() );\n\n  const finalOptions = { sessionSampleRate: 0, errorSampleRate: 0, ...dropUndefinedKeys(initialOptions) };\n\n  if (!opt) {\n    // eslint-disable-next-line no-console\n    console.warn('SDK client is not available.');\n    return finalOptions;\n  }\n\n  if (\n    initialOptions.sessionSampleRate == null && // TODO remove once deprecated rates are removed\n    initialOptions.errorSampleRate == null && // TODO remove once deprecated rates are removed\n    opt.replaysSessionSampleRate == null &&\n    opt.replaysOnErrorSampleRate == null\n  ) {\n    // eslint-disable-next-line no-console\n    console.warn(\n      'Replay is disabled because neither `replaysSessionSampleRate` nor `replaysOnErrorSampleRate` are set.',\n    );\n  }\n\n  if (typeof opt.replaysSessionSampleRate === 'number') {\n    finalOptions.sessionSampleRate = opt.replaysSessionSampleRate;\n  }\n\n  if (typeof opt.replaysOnErrorSampleRate === 'number') {\n    finalOptions.errorSampleRate = opt.replaysOnErrorSampleRate;\n  }\n\n  return finalOptions;\n}\n\nfunction _getMergedNetworkHeaders(headers) {\n  return [...DEFAULT_NETWORK_HEADERS, ...headers.map(header => header.toLowerCase())];\n}\n\nexport { Replay };\n//# sourceMappingURL=index.js.map\n"],"names":["WINDOW","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$1","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","selectorText","cssStringified","regex","fixSafariColons","NodeType","Mirror","constructor","this","idNodeMap","Map","nodeMetaMap","WeakMap","getId","_a","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","_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","url","indexOf","slice","extractOrigin","stack","parts","pop","part","SRCSET_NOT_SPACES","SRCSET_COMMAS_OR_SPACES","absoluteToDoc","doc","attributeValue","trim","a","createElement","isSVGElement","ownerSVGElement","getHref","document","transformAttribute","name","maskAttributeFn","pos","collectCharacters","regEx","chars","match","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","maskDistance","unmaskDistance","e","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","i","attr","stylesheet","styleSheets","find","rel","_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","oldValue","crossOrigin","recordInlineImage","removeEventListener","naturalWidth","naturalHeight","drawImage","err","console","warn","currentSrc","removeAttribute","complete","addEventListener","rr_mediaState","paused","rr_mediaCurrentTime","currentTime","scrollLeft","rr_scrollLeft","scrollTop","rr_scrollTop","getBoundingClientRect","class","rr_width","rr_height","src","contentDocument","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","as","endsWith","headFavicon","headMetaDescKeywords","headMetaSocial","property","headMetaRobots","headMetaHttpEquiv","headMetaAuthorship","headMetaVerification","slimDOMExcluded","serializedNode","assign","recordChild","isShadowHost","headWhitespace","bypassOptions","childN","serializedChildNode","isElement$1","isShadow","iframeEl","listener","win","contentWindow","readyState","fired","timer","setTimeout","clearTimeout","blankUrl","location","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","apply","trailing","hookSetter","key","d","isRevoked","window","original","getOwnPropertyDescriptor","defineProperty","patch","source","replacement","wrapped","defineProperties","__rrweb_original__","enumerable","Proxy","Reflect","prop","receiver","nowTimestamp","getWindowScroll","_b","_c","_d","_e","_f","left","scrollingElement","pageXOffset","documentElement","body","top","pageYOffset","getWindowHeight","innerHeight","clientHeight","getWindowWidth","innerWidth","clientWidth","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","EventType","EventType2","IncrementalSource","IncrementalSource2","MouseInteractions","MouseInteractions2","PointerTypes","PointerTypes2","isNodeInLinkedList","DoubleLinkedList","head","tail","position","Error","current","index","next","addNode","__ln","removeNode","moveKey","parentId","MutationBuffer","frozen","locked","texts","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","iframe","childSn","attachIframe","observeAttachShadow","attachLinkElement","shift","isParentRemoved","isAncestorInSet","candidate","tailNode","_node","unhandledNode","payload","filter","attribute","style","diffAsStr","styleDiff","unchangedAsStr","_unchangedStyles","mutationCb","m","unattachedDoc","implementation","createHTMLDocument","attributeName","isInputMasked","item","setAttribute","old","pname","newValue","getPropertyValue","newPriority","getPropertyPriority","addedNodes","genAdds","removedNodes","nodeId","isSerialized","deepDelete","processedNodeManager","inOtherBuffer","targetId","init","freeze","canvasManager","unfreeze","isFrozen","lock","unlock","addsSet","_isParentRemoved","r","size","_isAncestorInSet","errorHandler","registerErrorHandler","handler","unregisterErrorHandler","callbackWrapper","cb","rest","mutationBuffers","getEventTarget","path","composedPath","initMutationObserver","rootEl","mutationBuffer","mutationObserverCtor","MutationObserver","__rrMutationObserver","angularZoneSymbol","Zone","__symbol__","observer","onMutation","bind","observe","attributeOldValue","characterData","characterDataOldValue","childList","subtree","initMouseInteractionObserver","mouseInteractionCb","sampling","mouseInteraction","disableMap","handlers","currentPointerType","Number","isNaN","eventKey","eventName","pointerType","thisEventKey","Mouse","Touch","Pen","MouseDown","MouseUp","startsWith","Click","clientX","clientY","getHandler","PointerEvent","TouchStart","TouchEnd","h","initScrollObserver","scrollCb","evt","defaultView","scrollLeftTop","scroll","INPUT_TAGS","lastInputValueMap","initInputObserver","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","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","styleSheetRuleCb","CSSStyleSheet","insertRule","thisArg","argumentsList","deleteRule","replaceSync","supportedNestedCSSRuleTypes","canMonkeyPatchNestedCSSRule","unmodifiedFunctions","entries","typeKey","initStyleSheetObserver","adoptedStyleSheetObserver","styleDeclarationObserver","styleDeclarationCb","ignoreCSSAttributes","setProperty","CSSStyleDeclaration","priority","removeProperty","remove","initStyleDeclarationObserver","fontObserver","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","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","styles","iframeMirror","obj","isArray","child","ShadowDomManagerNoop","ShadowDomManager","shadowDoms","WeakSet","restoreHandlers","patchAttachShadow","iframeElement","manager","option","CanvasManagerNoop","StylesheetManager","trackedLinkElements","adoptedStyleSheetCb","linkEl","trackStylesheetInLinkElement","adoptedStyleSheetData","styleIds","CSSRule","ProcessedNodeManager","nodeMap","loop","periodicallyClear","requestAnimationFrame","clear","thisBuffer","buffers","destroy","wrapEvent","eWithTime","_takeFullSnapshot","record","checkoutEveryNms","checkoutEveryNth","maskAllInputs","_maskInputOptions","_slimDOMOptions","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__","__RRWEB_EXCLUDE_SHADOW_DOM__","slimDOM","snapshot","initialOffset","canvasMutationCb","CustomElement","plugins","ReplayEventTypeIncrementalSnapshot","timestampToMs","timestampToS","addBreadcrumbEvent","replay","breadcrumb","category","triggerUserActivity","checkAndHandleExpiredSession","addUpdate","throttledAddEvent","tag","INTERACTIVE_SELECTOR","getClosestInteractive","closest","getClickTargetNode","getTargetNode","isEventWithTarget","onWindowOpen","originalWindowOpen","splice","ClickDetector","slowClickConfig","_addBreadcrumbEvent","_lastMutation","_lastScroll","_clicks","_timeout","_threshold","_scollTimeout","scrollTimeout","_replay","_ignoreSelector","addListeners","cleanupWindowOpen","nowInSeconds","_teardown","removeListeners","_checkClickTimeout","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","createPerformanceEntry","performance","timeOrigin","setupPerformanceObserver","addPerformanceEntry","performanceEntries","onEntries","clearCallbacks","replayPerformanceEntries","lastEntry","getLargestContentfulPaint","clearCallback","logInfo","shouldAddBreadcrumb","__SENTRY_DEBUG__","info","addBreadcrumb","logInfoNextTick","logger","level","EventBufferSizeExceededError","super","EventBufferArray","events","_totalSize","hasCheckout","hasEvents","addEvent","eventSize","finish","Promise","resolve","eventsRet","getEarliestTimestamp","sort","WorkerHandler","worker","_worker","ensureReady","_ensureReadyPromise","reject","success","once","terminate","method","arg","_getAndIncrementId","response","EventBufferCompressionWorker","_earliestTimestamp","_sendEventToWorker","_finishRequest","EventBufferProxy","_fallback","_compression","_used","_ensureWorkerIsLoadedPromise","_ensureWorkerIsLoaded","ensureWorkerIsLoaded","_switchToCompressionWorker","addEventPromises","all","createEventBuffer","useCompression","workerUrl","customWorkerUrl","Worker","__SENTRY_EXCLUDE_REPLAY_WORKER__","Blob","URL","createObjectURL","_getWorkerUrl","_loadWorker","hasSessionStorage","sessionStorage","clearSession","removeItem","deleteSession","session","isSampled","sampleRate","random","saveSession","setItem","makeSession","started","lastActivity","segmentId","sampled","previousSessionId","createSession","sessionSampleRate","allowBuffering","stickySession","getSessionSampleType","isExpired","initialTime","expiry","targetTime","isSessionExpired","maxReplayDuration","sessionIdleExpire","shouldRefreshSession","loadOrCreateSession","traceInternals","sessionOptions","existingSession","sessionStringFromStorage","getItem","sessionObj","parse","fetchSession","addEventSync","shouldAddEvent","_addEvent","async","eventBuffer","recordingMode","eventAfterPossibleCallback","callback","isCustomEvent","maybeApplyCallback","getOptions","beforeAddRecordingEvent","reason","stop","client","getClient","recordDroppedEvent","isPaused","timestampInMs","timeouts","sessionIdlePause","initialTimestamp","_experiments","isErrorEvent","isTransactionEvent","handleAfterSendEvent","enforceStatusCode","transport","getTransport","__sentry__baseTransport__","isBaseTransportSend","sendResponse","replayContext","contexts","trace","trace_id","traceIds","handleTransactionEvent","event_id","errorIds","tags","replayId","beforeErrorSampling","sendBufferedReplayOrFlush","handleErrorEvent","handleGlobalEventListener","includeAfterSendEventHandling","afterSendHandler","hint","isReplayEvent","breadcrumbs","exception","values","originalException","__rrweb__","isRrwebError","captureExceptions","log","isErrorEventSampled","errorSampleRate","shouldSampleForBufferEvent","getSessionId","createPerformanceSpans","op","description","startTimestamp","endTimestamp","handleHistorySpanListener","to","handleHistory","urls","addNetworkBreadcrumb","shouldFilterRequest","handleXhrSpanListener","xhr","sentryXhrData","status_code","handleXhr","getBodySize","textEncoder","encode","URLSearchParams","FormData","formDataStr","_serializeFormData","ArrayBuffer","byteLength","parseContentLengthHeader","header","parseInt","getBodyString","makeNetworkReplayBreadcrumb","request","buildSkippedNetworkRequestOrResponse","bodySize","headers","_meta","warnings","buildNetworkRequestOrResponse","normalizedBody","exceedsSizeLimit","isProbablyJson","first","last","_strIsProbablyJson","truncatedBody","e3","normalizeNetworkBody","getAllowedHeaders","allowedHeaders","reduce","filteredHeaders","formData","urlMatches","fullUrl","baseURI","fixedUrl","getFullUrl","captureFetchBreadcrumbToReplay","request_body_size","requestBodySize","response_body_size","responseBodySize","captureDetails","networkDetailAllowUrls","networkDetailDenyUrls","networkCaptureBodies","networkRequestHeaders","fetchArgs","getHeadersFromOptions","getRequestHeaders","bodyStr","_getFetchRequestArgBody","_getRequestInfo","networkResponseHeaders","getAllHeaders","res","clone","bodyText","e2","_parseFetchBody","_getResponseInfo","_prepareFetchData","allHeaders","Headers","captureXhrBreadcrumbToReplay","xhrInfo","request_headers","getAllResponseHeaders","acc","line","getResponseHeaders","responseText","_prepareXhrData","handleNetworkBreadcrumbs","TextEncoder","_isXhrBreadcrumb","_isXhrHint","reqSize","resSize","getResponseHeader","enrichXhrBreadcrumb","_isFetchBreadcrumb","_isFetchHint","enrichFetchBreadcrumb","beforeAddNetworkBreadcrumb","fetchData","status","handleFetch","handleFetchSpanListener","_LAST_BREADCRUMB","handleScopeListener","scope","newBreadcrumb","getLastBreadcrumb","isBreadcrumbWithCategory","arguments","isTruncated","normalizedArgs","normalizedArg","normalizeConsoleBreadcrumb","handleScope","hasHooks","createMemoryEntry","memoryEntry","jsHeapSizeLimit","totalJSHeapSize","usedJSHeapSize","memory","getHandleRecordingEmit","hadFirstEvent","_isCheckout","setInitialState","useCompressionOption","blockAllMedia","networkDetailHasUrls","networkRequestHasHeaders","networkResponseHasHeaders","createOptionsEvent","addSettingsEvent","earliestEvent","flush","sendReplayRequest","recordingData","segment_id","eventContext","preparedRecordingData","payloadWithSequence","replayHeaders","sequence","prepareRecordingData","hub","getScope","dsn","getDsn","baseEvent","replay_start_timestamp","error_ids","trace_ids","replay_id","replay_type","replayEvent","eventHint","integrations","_integrations","preparedEvent","platform","metadata","getSdkMetadata","version","sdk","prepareReplayEvent","sdkProcessingMetadata","envelope","tunnel","createReplayEnvelope","send","cause","TransportStatusCodeError","rateLimits","RateLimitError","sendReplay","replayData","retryConfig","interval","_retryCount","THROTTLED","throttle","maxCount","durationSeconds","counter","isThrottled","floor","_cleanup","wasThrottled","ReplayContainer","recordingOptions","__init","__init2","__init3","__init4","__init5","__init6","_lastActivity","_isEnabled","_isPaused","_hasInitializedCoreListeners","_context","initialUrl","_recordingOptions","_options","_debouncedFlush","callbackReturnValue","timerId","maxTimerId","maxWait","max","invokeFunc","cancelTimers","debounced","cancel","debounce","_flush","flushMinDelay","flushMaxDelay","_throttledAddEvent","slowClickTimeout","slowClickIgnoreSelectors","initializeSampling","_initializeSessionForSampling","_initializeRecording","_handleException","startBuffering","startRecording","_stopRecording","_onMutationHandler","stopRecording","forceFlush","_removeListeners","force","pause","resume","_checkSession","continueRecording","flushImmediate","activityTime","hasStoppedRecording","_updateUserActivity","_updateSessionActivity","_maybeSaveSession","cbResult","conditionalFlush","cancelFlush","urlPath","pathname","hash","_clearContext","lastTransaction","getTransaction","_addListeners","currentSession","_refreshSession","_handleVisibilityChange","_handleWindowBlur","_handleWindowFocus","_handleKeyboardEvent","addScopeListener","addEventProcessor","dsc","transaction","addGlobalListeners","_performanceCleanupCallback","visibilityState","_doChangeToForegroundTasks","_doChangeToBackgroundTasks","_createCustomBreadcrumb","_addPerformanceEntries","concat","_updateInitialTimestampFromEventBuffer","_popEventContext","_runFlush","addMemoryEntry","tooShort","minReplayDuration","tooLong","_flushLock","mutationLimit","overMutationLimit","mutationBreadcrumbLimit","getOption","selectors","defaultSelectors","deprecatedClassOption","deprecatedSelectorOption","allSelectors","MEDIA_SELECTORS","DEFAULT_NETWORK_HEADERS","_initialized","Replay","__initStatic","mask","maskAttributes","unmask","block","unblock","ignore","maskFn","privacyOptions","getPrivacyOptions","password","maskAttribute","_initialOptions","_getMergedNetworkHeaders","_isInitialized","setupOnce","_setup","_initialize","getReplayId","finalOptions","initialOptions","opt","replaysSessionSampleRate","replaysOnErrorSampleRate","loadReplayOptionsFromClient"],"sourceRoot":""}