{"version":3,"file":"vendors-480cd651.xxxxxxxx.bundle.js","mappings":"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","sources":["webpack://iadviser/./node_modules/@sentry/replay/esm/index.js"],"sourcesContent":["import { _nullishCoalesce, _optionalChain } from '@sentry/utils';\nimport { addBreadcrumb, getClient, isSentryRequestUrl, getCurrentScope, addEventProcessor, prepareEvent, getIsolationScope, setContext, captureException, spanToJSON, SEMANTIC_ATTRIBUTE_SENTRY_SOURCE } from '@sentry/core';\nimport { GLOBAL_OBJ, normalize, fill, htmlTreeAsString, browserPerformanceTimeOrigin, logger, uuid4, SENTRY_XHR_DATA_KEY, dropUndefinedKeys, stringMatchesSomePattern, addFetchInstrumentationHandler, addXhrInstrumentationHandler, addClickKeypressInstrumentationHandler, addHistoryInstrumentationHandler, createEnvelope, createEventEnvelopeHeaders, getSdkMetadataForEnvelopeHeader, updateRateLimits, isRateLimited, consoleSandbox, 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\nfunction _nullishCoalesce$1(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }function _optionalChain$5(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var NodeType$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 = _optionalChain$5([n, 'optionalAccess', _ => _.host]);\n    return Boolean(_optionalChain$5([host, 'optionalAccess', _2 => _2.shadowRoot]) === n);\n}\nfunction isNativeShadowDom(shadowRoot) {\n    return Object.prototype.toString.call(shadowRoot) === '[object ShadowRoot]';\n}\nfunction fixBrowserCompatibilityIssuesInCSS(cssText) {\n    if (cssText.includes(' background-clip: text;') &&\n        !cssText.includes(' -webkit-background-clip: text;')) {\n        cssText = cssText.replace(' 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        if (!n)\n            return -1;\n        const id = _optionalChain$5([this, 'access', _3 => _3.getMeta, 'call', _4 => _4(n), 'optionalAccess', _5 => _5.id]);\n        return _nullishCoalesce$1(id, () => ( -1));\n    }\n    getNode(id) {\n        return this.idNodeMap.get(id) || null;\n    }\n    getIds() {\n        return Array.from(this.idNodeMap.keys());\n    }\n    getMeta(n) {\n        return this.nodeMetaMap.get(n) || null;\n    }\n    removeNodeFromMap(n) {\n        const id = this.getId(n);\n        this.idNodeMap.delete(id);\n        if (n.childNodes) {\n            n.childNodes.forEach((childNode) => this.removeNodeFromMap(childNode));\n        }\n    }\n    has(id) {\n        return this.idNodeMap.has(id);\n    }\n    hasNode(node) {\n        return this.nodeMetaMap.has(node);\n    }\n    add(n, meta) {\n        const id = meta.id;\n        this.idNodeMap.set(id, n);\n        this.nodeMetaMap.set(n, meta);\n    }\n    replace(id, n) {\n        const oldNode = this.getNode(id);\n        if (oldNode) {\n            const meta = this.nodeMetaMap.get(oldNode);\n            if (meta)\n                this.nodeMetaMap.set(n, meta);\n        }\n        this.idNodeMap.set(id, n);\n    }\n    reset() {\n        this.idNodeMap = new Map();\n        this.nodeMetaMap = new WeakMap();\n    }\n}\nfunction createMirror() {\n    return new Mirror();\n}\nfunction shouldMaskInput({ maskInputOptions, tagName, type, }) {\n    if (tagName === 'OPTION') {\n        tagName = 'SELECT';\n    }\n    return Boolean(maskInputOptions[tagName.toLowerCase()] ||\n        (type && maskInputOptions[type]) ||\n        type === 'password' ||\n        (tagName === 'INPUT' && !type && maskInputOptions['text']));\n}\nfunction maskInputValue({ isMasked, element, value, maskInputFn, }) {\n    let text = value || '';\n    if (!isMasked) {\n        return text;\n    }\n    if (maskInputFn) {\n        text = maskInputFn(text, element);\n    }\n    return '*'.repeat(text.length);\n}\nfunction toLowerCase(str) {\n    return str.toLowerCase();\n}\nfunction toUpperCase(str) {\n    return str.toUpperCase();\n}\nconst ORIGINAL_ATTRIBUTE_NAME = '__rrweb_original__';\nfunction is2DCanvasBlank(canvas) {\n    const ctx = canvas.getContext('2d');\n    if (!ctx)\n        return true;\n    const chunkSize = 50;\n    for (let x = 0; x < canvas.width; x += chunkSize) {\n        for (let y = 0; y < canvas.height; y += chunkSize) {\n            const getImageData = ctx.getImageData;\n            const originalGetImageData = ORIGINAL_ATTRIBUTE_NAME in getImageData\n                ? getImageData[ORIGINAL_ATTRIBUTE_NAME]\n                : getImageData;\n            const pixelBuffer = new Uint32Array(originalGetImageData.call(ctx, x, y, Math.min(chunkSize, canvas.width - x), Math.min(chunkSize, canvas.height - y)).data.buffer);\n            if (pixelBuffer.some((pixel) => pixel !== 0))\n                return false;\n        }\n    }\n    return true;\n}\nfunction getInputType(element) {\n    const type = element.type;\n    return element.hasAttribute('data-rr-is-password')\n        ? 'password'\n        : type\n            ?\n                toLowerCase(type)\n            : null;\n}\nfunction getInputValue(el, tagName, type) {\n    if (tagName === 'INPUT' && (type === 'radio' || type === 'checkbox')) {\n        return el.getAttribute('value') || '';\n    }\n    return el.value;\n}\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        try {\n            if (className) {\n                if (typeof className === 'string') {\n                    if (el.matches(`.${className}`))\n                        return true;\n                }\n                else if (elementClassMatchesRegex(el, className)) {\n                    return true;\n                }\n            }\n            if (selector && el.matches(selector))\n                return true;\n            return false;\n        }\n        catch (e2) {\n            return false;\n        }\n    };\n}\nfunction needMaskingText(node, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, maskAllText) {\n    try {\n        const el = node.nodeType === node.ELEMENT_NODE\n            ? node\n            : node.parentElement;\n        if (el === null)\n            return false;\n        if (el.tagName === 'INPUT') {\n            const autocomplete = el.getAttribute('autocomplete');\n            const disallowedAutocompleteValues = [\n                'current-password',\n                'new-password',\n                'cc-number',\n                'cc-exp',\n                'cc-exp-month',\n                'cc-exp-year',\n                'cc-csc',\n            ];\n            if (disallowedAutocompleteValues.includes(autocomplete)) {\n                return true;\n            }\n        }\n        let maskDistance = -1;\n        let unmaskDistance = -1;\n        if (maskAllText) {\n            unmaskDistance = distanceToMatch(el, createMatchPredicate(unmaskTextClass, unmaskTextSelector));\n            if (unmaskDistance < 0) {\n                return true;\n            }\n            maskDistance = distanceToMatch(el, createMatchPredicate(maskTextClass, maskTextSelector), unmaskDistance >= 0 ? unmaskDistance : Infinity);\n        }\n        else {\n            maskDistance = distanceToMatch(el, createMatchPredicate(maskTextClass, maskTextSelector));\n            if (maskDistance < 0) {\n                return false;\n            }\n            unmaskDistance = distanceToMatch(el, createMatchPredicate(unmaskTextClass, unmaskTextSelector), maskDistance >= 0 ? maskDistance : Infinity);\n        }\n        return maskDistance >= 0\n            ? unmaskDistance >= 0\n                ? maskDistance <= unmaskDistance\n                : true\n            : unmaskDistance >= 0\n                ? false\n                : !!maskAllText;\n    }\n    catch (e) {\n    }\n    return !!maskAllText;\n}\nfunction onceIframeLoaded(iframeEl, listener, iframeLoadTimeout) {\n    const win = iframeEl.contentWindow;\n    if (!win) {\n        return;\n    }\n    let fired = false;\n    let readyState;\n    try {\n        readyState = win.document.readyState;\n    }\n    catch (error) {\n        return;\n    }\n    if (readyState !== 'complete') {\n        const timer = setTimeout(() => {\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    const { maskAllText, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, maskTextFn, maskInputOptions, maskInputFn, rootId, } = options;\n    const parentTagName = n.parentNode && n.parentNode.tagName;\n    let textContent = n.textContent;\n    const isStyle = parentTagName === 'STYLE' ? true : undefined;\n    const isScript = parentTagName === 'SCRIPT' ? true : undefined;\n    const isTextarea = parentTagName === 'TEXTAREA' ? true : undefined;\n    if (isStyle && textContent) {\n        try {\n            if (n.nextSibling || n.previousSibling) {\n            }\n            else if (_optionalChain$5([n, 'access', _6 => _6.parentNode, 'access', _7 => _7.sheet, 'optionalAccess', _8 => _8.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.parentElement)\n            : textContent.replace(/[\\S]/g, '*');\n    }\n    if (isTextarea && textContent && (maskInputOptions.textarea || forceMask)) {\n        textContent = maskInputFn\n            ? maskInputFn(textContent, n.parentNode)\n            : textContent.replace(/[\\S]/g, '*');\n    }\n    if (parentTagName === 'OPTION' && textContent) {\n        const isInputMasked = shouldMaskInput({\n            type: null,\n            tagName: parentTagName,\n            maskInputOptions,\n        });\n        textContent = maskInputValue({\n            isMasked: needMaskingText(n, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, isInputMasked),\n            element: n,\n            value: textContent,\n            maskInputFn,\n        });\n    }\n    return {\n        type: NodeType$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 (attr.name && !ignoreAttribute(tagName, attr.name, attr.value)) {\n            attributes[attr.name] = transformAttribute(doc, tagName, toLowerCase(attr.name), attr.value, n, maskAttributeFn);\n        }\n    }\n    if (tagName === 'link' && inlineStylesheet) {\n        const stylesheet = Array.from(doc.styleSheets).find((s) => {\n            return s.href === n.href;\n        });\n        let cssText = null;\n        if (stylesheet) {\n            cssText = stringifyStylesheet(stylesheet);\n        }\n        if (cssText) {\n            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 _optionalChain$4(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }\nfunction on(type, fn, target = document) {\n    const options = { capture: true, passive: true };\n    target.addEventListener(type, fn, options);\n    return () => target.removeEventListener(type, fn, options);\n}\nconst DEPARTED_MIRROR_ACCESS_WARNING = 'Please stop import mirror directly. Instead of that,' +\n    '\\r\\n' +\n    'now you can use replayer.getMirror() to access the mirror instance of a replayer,' +\n    '\\r\\n' +\n    'or you can use record.mirror to access the mirror instance during recording.';\nlet _mirror = {\n    map: {},\n    getId() {\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n        return -1;\n    },\n    getNode() {\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n        return null;\n    },\n    removeNodeFromMap() {\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n    },\n    has() {\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n        return false;\n    },\n    reset() {\n        console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n    },\n};\nif (typeof window !== 'undefined' && window.Proxy && window.Reflect) {\n    _mirror = new Proxy(_mirror, {\n        get(target, prop, receiver) {\n            if (prop === 'map') {\n                console.error(DEPARTED_MIRROR_ACCESS_WARNING);\n            }\n            return Reflect.get(target, prop, receiver);\n        },\n    });\n}\nfunction throttle$1(func, wait, options = {}) {\n    let timeout = null;\n    let previous = 0;\n    return function (...args) {\n        const now = Date.now();\n        if (!previous && options.leading === false) {\n            previous = now;\n        }\n        const remaining = wait - (now - previous);\n        const context = this;\n        if (remaining <= 0 || remaining > wait) {\n            if (timeout) {\n                clearTimeout$1(timeout);\n                timeout = null;\n            }\n            previous = now;\n            func.apply(context, args);\n        }\n        else if (!timeout && options.trailing !== false) {\n            timeout = setTimeout$1(() => {\n                previous = options.leading === false ? 0 : Date.now();\n                timeout = null;\n                func.apply(context, args);\n            }, remaining);\n        }\n    };\n}\nfunction hookSetter(target, key, d, isRevoked, win = window) {\n    const original = win.Object.getOwnPropertyDescriptor(target, key);\n    win.Object.defineProperty(target, key, isRevoked\n        ? d\n        : {\n            set(value) {\n                setTimeout$1(() => {\n                    d.set.call(this, value);\n                }, 0);\n                if (original && original.set) {\n                    original.set.call(this, value);\n                }\n            },\n        });\n    return () => hookSetter(target, key, original || {}, true);\n}\nfunction patch(source, name, replacement) {\n    try {\n        if (!(name in source)) {\n            return () => {\n            };\n        }\n        const original = source[name];\n        const wrapped = replacement(original);\n        if (typeof wrapped === 'function') {\n            wrapped.prototype = wrapped.prototype || {};\n            Object.defineProperties(wrapped, {\n                __rrweb_original__: {\n                    enumerable: false,\n                    value: original,\n                },\n            });\n        }\n        source[name] = wrapped;\n        return () => {\n            source[name] = original;\n        };\n    }\n    catch (e2) {\n        return () => {\n        };\n    }\n}\nlet nowTimestamp = Date.now;\nif (!(/[1-9][0-9]{12}/.test(Date.now().toString()))) {\n    nowTimestamp = () => new Date().getTime();\n}\nfunction getWindowScroll(win) {\n    const doc = win.document;\n    return {\n        left: doc.scrollingElement\n            ? doc.scrollingElement.scrollLeft\n            : win.pageXOffset !== undefined\n                ? win.pageXOffset\n                : _optionalChain$4([doc, 'optionalAccess', _ => _.documentElement, 'access', _2 => _2.scrollLeft]) ||\n                    _optionalChain$4([doc, 'optionalAccess', _3 => _3.body, 'optionalAccess', _4 => _4.parentElement, 'optionalAccess', _5 => _5.scrollLeft]) ||\n                    _optionalChain$4([doc, 'optionalAccess', _6 => _6.body, 'optionalAccess', _7 => _7.scrollLeft]) ||\n                    0,\n        top: doc.scrollingElement\n            ? doc.scrollingElement.scrollTop\n            : win.pageYOffset !== undefined\n                ? win.pageYOffset\n                : _optionalChain$4([doc, 'optionalAccess', _8 => _8.documentElement, 'access', _9 => _9.scrollTop]) ||\n                    _optionalChain$4([doc, 'optionalAccess', _10 => _10.body, 'optionalAccess', _11 => _11.parentElement, 'optionalAccess', _12 => _12.scrollTop]) ||\n                    _optionalChain$4([doc, 'optionalAccess', _13 => _13.body, 'optionalAccess', _14 => _14.scrollTop]) ||\n                    0,\n    };\n}\nfunction getWindowHeight() {\n    return (window.innerHeight ||\n        (document.documentElement && document.documentElement.clientHeight) ||\n        (document.body && document.body.clientHeight));\n}\nfunction getWindowWidth() {\n    return (window.innerWidth ||\n        (document.documentElement && document.documentElement.clientWidth) ||\n        (document.body && document.body.clientWidth));\n}\nfunction closestElementOfNode(node) {\n    if (!node) {\n        return null;\n    }\n    const el = node.nodeType === node.ELEMENT_NODE\n        ? node\n        : node.parentElement;\n    return el;\n}\nfunction isBlocked(node, blockClass, blockSelector, unblockSelector, checkAncestors) {\n    if (!node) {\n        return false;\n    }\n    const el = closestElementOfNode(node);\n    if (!el) {\n        return false;\n    }\n    const blockedPredicate = createMatchPredicate(blockClass, blockSelector);\n    if (!checkAncestors) {\n        const isUnblocked = unblockSelector && el.matches(unblockSelector);\n        return blockedPredicate(el) && !isUnblocked;\n    }\n    const blockDistance = distanceToMatch(el, blockedPredicate);\n    let unblockDistance = -1;\n    if (blockDistance < 0) {\n        return false;\n    }\n    if (unblockSelector) {\n        unblockDistance = distanceToMatch(el, createMatchPredicate(null, unblockSelector));\n    }\n    if (blockDistance > -1 && unblockDistance < 0) {\n        return true;\n    }\n    return blockDistance < unblockDistance;\n}\nfunction isSerialized(n, mirror) {\n    return mirror.getId(n) !== -1;\n}\nfunction isIgnored(n, mirror) {\n    return mirror.getId(n) === IGNORED_NODE;\n}\nfunction isAncestorRemoved(target, mirror) {\n    if (isShadowRoot(target)) {\n        return false;\n    }\n    const id = mirror.getId(target);\n    if (!mirror.has(id)) {\n        return true;\n    }\n    if (target.parentNode &&\n        target.parentNode.nodeType === target.DOCUMENT_NODE) {\n        return false;\n    }\n    if (!target.parentNode) {\n        return true;\n    }\n    return isAncestorRemoved(target.parentNode, mirror);\n}\nfunction legacy_isTouchEvent(event) {\n    return Boolean(event.changedTouches);\n}\nfunction polyfill(win = window) {\n    if ('NodeList' in win && !win.NodeList.prototype.forEach) {\n        win.NodeList.prototype.forEach = Array.prototype\n            .forEach;\n    }\n    if ('DOMTokenList' in win && !win.DOMTokenList.prototype.forEach) {\n        win.DOMTokenList.prototype.forEach = Array.prototype\n            .forEach;\n    }\n    if (!Node.prototype.contains) {\n        Node.prototype.contains = (...args) => {\n            let node = args[0];\n            if (!(0 in args)) {\n                throw new TypeError('1 argument is required');\n            }\n            do {\n                if (this === node) {\n                    return true;\n                }\n            } while ((node = node && node.parentNode));\n            return false;\n        };\n    }\n}\nfunction isSerializedIframe(n, mirror) {\n    return Boolean(n.nodeName === 'IFRAME' && mirror.getMeta(n));\n}\nfunction isSerializedStylesheet(n, mirror) {\n    return Boolean(n.nodeName === 'LINK' &&\n        n.nodeType === n.ELEMENT_NODE &&\n        n.getAttribute &&\n        n.getAttribute('rel') === 'stylesheet' &&\n        mirror.getMeta(n));\n}\nfunction hasShadowRoot(n) {\n    return Boolean(_optionalChain$4([n, 'optionalAccess', _18 => _18.shadowRoot]));\n}\nclass StyleSheetMirror {\n    constructor() {\n        this.id = 1;\n        this.styleIDMap = new WeakMap();\n        this.idStyleMap = new Map();\n    }\n    getId(stylesheet) {\n        return _nullishCoalesce(this.styleIDMap.get(stylesheet), () => ( -1));\n    }\n    has(stylesheet) {\n        return this.styleIDMap.has(stylesheet);\n    }\n    add(stylesheet, id) {\n        if (this.has(stylesheet))\n            return this.getId(stylesheet);\n        let newId;\n        if (id === undefined) {\n            newId = this.id++;\n        }\n        else\n            newId = id;\n        this.styleIDMap.set(stylesheet, newId);\n        this.idStyleMap.set(newId, stylesheet);\n        return newId;\n    }\n    getStyle(id) {\n        return this.idStyleMap.get(id) || null;\n    }\n    reset() {\n        this.styleIDMap = new WeakMap();\n        this.idStyleMap = new Map();\n        this.id = 1;\n    }\n    generateId() {\n        return this.id++;\n    }\n}\nfunction getShadowHost(n) {\n    let shadowHost = null;\n    if (_optionalChain$4([n, 'access', _19 => _19.getRootNode, 'optionalCall', _20 => _20(), 'optionalAccess', _21 => _21.nodeType]) === Node.DOCUMENT_FRAGMENT_NODE &&\n        n.getRootNode().host)\n        shadowHost = n.getRootNode().host;\n    return shadowHost;\n}\nfunction getRootShadowHost(n) {\n    let rootShadowHost = n;\n    let shadowHost;\n    while ((shadowHost = getShadowHost(rootShadowHost)))\n        rootShadowHost = shadowHost;\n    return rootShadowHost;\n}\nfunction shadowHostInDom(n) {\n    const doc = n.ownerDocument;\n    if (!doc)\n        return false;\n    const shadowHost = getRootShadowHost(n);\n    return doc.contains(shadowHost);\n}\nfunction inDom(n) {\n    const doc = n.ownerDocument;\n    if (!doc)\n        return false;\n    return doc.contains(n) || shadowHostInDom(n);\n}\nconst cachedImplementations = {};\nfunction getImplementation(name) {\n    const cached = cachedImplementations[name];\n    if (cached) {\n        return cached;\n    }\n    const document = window.document;\n    let impl = window[name];\n    if (document && typeof document.createElement === 'function') {\n        try {\n            const sandbox = document.createElement('iframe');\n            sandbox.hidden = true;\n            document.head.appendChild(sandbox);\n            const contentWindow = sandbox.contentWindow;\n            if (contentWindow && contentWindow[name]) {\n                impl =\n                    contentWindow[name];\n            }\n            document.head.removeChild(sandbox);\n        }\n        catch (e) {\n        }\n    }\n    return (cachedImplementations[name] = impl.bind(window));\n}\nfunction onRequestAnimationFrame(...rest) {\n    return getImplementation('requestAnimationFrame')(...rest);\n}\nfunction setTimeout$1(...rest) {\n    return getImplementation('setTimeout')(...rest);\n}\nfunction clearTimeout$1(...rest) {\n    return getImplementation('clearTimeout')(...rest);\n}\n\nvar EventType = /* @__PURE__ */ ((EventType2) => {\n  EventType2[EventType2[\"DomContentLoaded\"] = 0] = \"DomContentLoaded\";\n  EventType2[EventType2[\"Load\"] = 1] = \"Load\";\n  EventType2[EventType2[\"FullSnapshot\"] = 2] = \"FullSnapshot\";\n  EventType2[EventType2[\"IncrementalSnapshot\"] = 3] = \"IncrementalSnapshot\";\n  EventType2[EventType2[\"Meta\"] = 4] = \"Meta\";\n  EventType2[EventType2[\"Custom\"] = 5] = \"Custom\";\n  EventType2[EventType2[\"Plugin\"] = 6] = \"Plugin\";\n  return EventType2;\n})(EventType || {});\nvar IncrementalSource = /* @__PURE__ */ ((IncrementalSource2) => {\n  IncrementalSource2[IncrementalSource2[\"Mutation\"] = 0] = \"Mutation\";\n  IncrementalSource2[IncrementalSource2[\"MouseMove\"] = 1] = \"MouseMove\";\n  IncrementalSource2[IncrementalSource2[\"MouseInteraction\"] = 2] = \"MouseInteraction\";\n  IncrementalSource2[IncrementalSource2[\"Scroll\"] = 3] = \"Scroll\";\n  IncrementalSource2[IncrementalSource2[\"ViewportResize\"] = 4] = \"ViewportResize\";\n  IncrementalSource2[IncrementalSource2[\"Input\"] = 5] = \"Input\";\n  IncrementalSource2[IncrementalSource2[\"TouchMove\"] = 6] = \"TouchMove\";\n  IncrementalSource2[IncrementalSource2[\"MediaInteraction\"] = 7] = \"MediaInteraction\";\n  IncrementalSource2[IncrementalSource2[\"StyleSheetRule\"] = 8] = \"StyleSheetRule\";\n  IncrementalSource2[IncrementalSource2[\"CanvasMutation\"] = 9] = \"CanvasMutation\";\n  IncrementalSource2[IncrementalSource2[\"Font\"] = 10] = \"Font\";\n  IncrementalSource2[IncrementalSource2[\"Log\"] = 11] = \"Log\";\n  IncrementalSource2[IncrementalSource2[\"Drag\"] = 12] = \"Drag\";\n  IncrementalSource2[IncrementalSource2[\"StyleDeclaration\"] = 13] = \"StyleDeclaration\";\n  IncrementalSource2[IncrementalSource2[\"Selection\"] = 14] = \"Selection\";\n  IncrementalSource2[IncrementalSource2[\"AdoptedStyleSheet\"] = 15] = \"AdoptedStyleSheet\";\n  IncrementalSource2[IncrementalSource2[\"CustomElement\"] = 16] = \"CustomElement\";\n  return IncrementalSource2;\n})(IncrementalSource || {});\nvar MouseInteractions = /* @__PURE__ */ ((MouseInteractions2) => {\n  MouseInteractions2[MouseInteractions2[\"MouseUp\"] = 0] = \"MouseUp\";\n  MouseInteractions2[MouseInteractions2[\"MouseDown\"] = 1] = \"MouseDown\";\n  MouseInteractions2[MouseInteractions2[\"Click\"] = 2] = \"Click\";\n  MouseInteractions2[MouseInteractions2[\"ContextMenu\"] = 3] = \"ContextMenu\";\n  MouseInteractions2[MouseInteractions2[\"DblClick\"] = 4] = \"DblClick\";\n  MouseInteractions2[MouseInteractions2[\"Focus\"] = 5] = \"Focus\";\n  MouseInteractions2[MouseInteractions2[\"Blur\"] = 6] = \"Blur\";\n  MouseInteractions2[MouseInteractions2[\"TouchStart\"] = 7] = \"TouchStart\";\n  MouseInteractions2[MouseInteractions2[\"TouchMove_Departed\"] = 8] = \"TouchMove_Departed\";\n  MouseInteractions2[MouseInteractions2[\"TouchEnd\"] = 9] = \"TouchEnd\";\n  MouseInteractions2[MouseInteractions2[\"TouchCancel\"] = 10] = \"TouchCancel\";\n  return MouseInteractions2;\n})(MouseInteractions || {});\nvar PointerTypes = /* @__PURE__ */ ((PointerTypes2) => {\n  PointerTypes2[PointerTypes2[\"Mouse\"] = 0] = \"Mouse\";\n  PointerTypes2[PointerTypes2[\"Pen\"] = 1] = \"Pen\";\n  PointerTypes2[PointerTypes2[\"Touch\"] = 2] = \"Touch\";\n  return PointerTypes2;\n})(PointerTypes || {});\n\nfunction _optionalChain$3(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }\nfunction isNodeInLinkedList(n) {\n    return '__ln' in n;\n}\nclass DoubleLinkedList {\n    constructor() {\n        this.length = 0;\n        this.head = null;\n        this.tail = null;\n    }\n    get(position) {\n        if (position >= this.length) {\n            throw new Error('Position outside of list range');\n        }\n        let current = this.head;\n        for (let index = 0; index < position; index++) {\n            current = _optionalChain$3([current, 'optionalAccess', _ => _.next]) || null;\n        }\n        return current;\n    }\n    addNode(n) {\n        const node = {\n            value: n,\n            previous: null,\n            next: null,\n        };\n        n.__ln = node;\n        if (n.previousSibling && isNodeInLinkedList(n.previousSibling)) {\n            const current = n.previousSibling.__ln.next;\n            node.next = current;\n            node.previous = n.previousSibling.__ln;\n            n.previousSibling.__ln.next = node;\n            if (current) {\n                current.previous = node;\n            }\n        }\n        else if (n.nextSibling &&\n            isNodeInLinkedList(n.nextSibling) &&\n            n.nextSibling.__ln.previous) {\n            const current = n.nextSibling.__ln.previous;\n            node.previous = current;\n            node.next = n.nextSibling.__ln;\n            n.nextSibling.__ln.previous = node;\n            if (current) {\n                current.next = node;\n            }\n        }\n        else {\n            if (this.head) {\n                this.head.previous = node;\n            }\n            node.next = this.head;\n            this.head = node;\n        }\n        if (node.next === null) {\n            this.tail = node;\n        }\n        this.length++;\n    }\n    removeNode(n) {\n        const current = n.__ln;\n        if (!this.head) {\n            return;\n        }\n        if (!current.previous) {\n            this.head = current.next;\n            if (this.head) {\n                this.head.previous = null;\n            }\n            else {\n                this.tail = null;\n            }\n        }\n        else {\n            current.previous.next = current.next;\n            if (current.next) {\n                current.next.previous = current.previous;\n            }\n            else {\n                this.tail = current.previous;\n            }\n        }\n        if (n.__ln) {\n            delete n.__ln;\n        }\n        this.length--;\n    }\n}\nconst moveKey = (id, parentId) => `${id}@${parentId}`;\nclass MutationBuffer {\n    constructor() {\n        this.frozen = false;\n        this.locked = false;\n        this.texts = [];\n        this.attributes = [];\n        this.attributeMap = new WeakMap();\n        this.removes = [];\n        this.mapRemoves = [];\n        this.movedMap = {};\n        this.addedSet = new Set();\n        this.movedSet = new Set();\n        this.droppedSet = new Set();\n        this.processMutations = (mutations) => {\n            mutations.forEach(this.processMutation);\n            this.emit();\n        };\n        this.emit = () => {\n            if (this.frozen || this.locked) {\n                return;\n            }\n            const adds = [];\n            const addedIds = new Set();\n            const addList = new DoubleLinkedList();\n            const getNextId = (n) => {\n                let ns = n;\n                let nextId = IGNORED_NODE;\n                while (nextId === IGNORED_NODE) {\n                    ns = ns && ns.nextSibling;\n                    nextId = ns && this.mirror.getId(ns);\n                }\n                return nextId;\n            };\n            const pushAdd = (n) => {\n                if (!n.parentNode || !inDom(n)) {\n                    return;\n                }\n                const parentId = isShadowRoot(n.parentNode)\n                    ? this.mirror.getId(getShadowHost(n))\n                    : this.mirror.getId(n.parentNode);\n                const nextId = getNextId(n);\n                if (parentId === -1 || nextId === -1) {\n                    return addList.addNode(n);\n                }\n                const sn = serializeNodeWithId(n, {\n                    doc: this.doc,\n                    mirror: this.mirror,\n                    blockClass: this.blockClass,\n                    blockSelector: this.blockSelector,\n                    maskAllText: this.maskAllText,\n                    unblockSelector: this.unblockSelector,\n                    maskTextClass: this.maskTextClass,\n                    unmaskTextClass: this.unmaskTextClass,\n                    maskTextSelector: this.maskTextSelector,\n                    unmaskTextSelector: this.unmaskTextSelector,\n                    skipChild: true,\n                    newlyAddedElement: true,\n                    inlineStylesheet: this.inlineStylesheet,\n                    maskInputOptions: this.maskInputOptions,\n                    maskAttributeFn: this.maskAttributeFn,\n                    maskTextFn: this.maskTextFn,\n                    maskInputFn: this.maskInputFn,\n                    slimDOMOptions: this.slimDOMOptions,\n                    dataURLOptions: this.dataURLOptions,\n                    recordCanvas: this.recordCanvas,\n                    inlineImages: this.inlineImages,\n                    onSerialize: (currentN) => {\n                        if (isSerializedIframe(currentN, this.mirror)) {\n                            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.attributeMap = new WeakMap();\n            this.removes = [];\n            this.addedSet = new Set();\n            this.movedSet = new Set();\n            this.droppedSet = new Set();\n            this.movedMap = {};\n            this.mutationCb(payload);\n        };\n        this.processMutation = (m) => {\n            if (isIgnored(m.target, this.mirror)) {\n                return;\n            }\n            switch (m.type) {\n                case 'characterData': {\n                    const value = m.target.textContent;\n                    if (!isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, false) &&\n                        value !== m.oldValue) {\n                        this.texts.push({\n                            value: needMaskingText(m.target, this.maskTextClass, this.maskTextSelector, this.unmaskTextClass, this.unmaskTextSelector, this.maskAllText) && value\n                                ? this.maskTextFn\n                                    ? this.maskTextFn(value, closestElementOfNode(m.target))\n                                    : value.replace(/[\\S]/g, '*')\n                                : value,\n                            node: m.target,\n                        });\n                    }\n                    break;\n                }\n                case 'attributes': {\n                    const target = m.target;\n                    let attributeName = m.attributeName;\n                    let value = m.target.getAttribute(attributeName);\n                    if (attributeName === 'value') {\n                        const type = getInputType(target);\n                        const tagName = target.tagName;\n                        value = getInputValue(target, tagName, type);\n                        const isInputMasked = shouldMaskInput({\n                            maskInputOptions: this.maskInputOptions,\n                            tagName,\n                            type,\n                        });\n                        const forceMask = needMaskingText(m.target, this.maskTextClass, this.maskTextSelector, this.unmaskTextClass, this.unmaskTextSelector, isInputMasked);\n                        value = maskInputValue({\n                            isMasked: forceMask,\n                            element: target,\n                            value,\n                            maskInputFn: this.maskInputFn,\n                        });\n                    }\n                    if (isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, false) ||\n                        value === m.oldValue) {\n                        return;\n                    }\n                    let item = this.attributeMap.get(m.target);\n                    if (target.tagName === 'IFRAME' &&\n                        attributeName === 'src' &&\n                        !this.keepIframeSrcFn(value)) {\n                        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                        this.attributeMap.set(m.target, item);\n                    }\n                    if (attributeName === 'type' &&\n                        target.tagName === 'INPUT' &&\n                        (m.oldValue || '').toLowerCase() === 'password') {\n                        target.setAttribute('data-rr-is-password', 'true');\n                    }\n                    if (!ignoreAttribute(target.tagName, attributeName)) {\n                        item.attributes[attributeName] = transformAttribute(this.doc, toLowerCase(target.tagName), toLowerCase(attributeName), value, target, this.maskAttributeFn);\n                        if (attributeName === 'style') {\n                            if (!this.unattachedDoc) {\n                                try {\n                                    this.unattachedDoc =\n                                        document.implementation.createHTMLDocument();\n                                }\n                                catch (e) {\n                                    this.unattachedDoc = this.doc;\n                                }\n                            }\n                            const old = this.unattachedDoc.createElement('span');\n                            if (m.oldValue) {\n                                old.setAttribute('style', m.oldValue);\n                            }\n                            for (const pname of Array.from(target.style)) {\n                                const newValue = target.style.getPropertyValue(pname);\n                                const newPriority = target.style.getPropertyPriority(pname);\n                                if (newValue !== old.style.getPropertyValue(pname) ||\n                                    newPriority !== old.style.getPropertyPriority(pname)) {\n                                    if (newPriority === '') {\n                                        item.styleDiff[pname] = newValue;\n                                    }\n                                    else {\n                                        item.styleDiff[pname] = [newValue, newPriority];\n                                    }\n                                }\n                                else {\n                                    item._unchangedStyles[pname] = [newValue, newPriority];\n                                }\n                            }\n                            for (const pname of Array.from(old.style)) {\n                                if (target.style.getPropertyValue(pname) === '') {\n                                    item.styleDiff[pname] = false;\n                                }\n                            }\n                        }\n                    }\n                    break;\n                }\n                case 'childList': {\n                    if (isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, true)) {\n                        return;\n                    }\n                    m.addedNodes.forEach((n) => this.genAdds(n, m.target));\n                    m.removedNodes.forEach((n) => {\n                        const nodeId = this.mirror.getId(n);\n                        const parentId = isShadowRoot(m.target)\n                            ? this.mirror.getId(m.target.host)\n                            : this.mirror.getId(m.target);\n                        if (isBlocked(m.target, this.blockClass, this.blockSelector, this.unblockSelector, false) ||\n                            isIgnored(n, this.mirror) ||\n                            !isSerialized(n, this.mirror)) {\n                            return;\n                        }\n                        if (this.addedSet.has(n)) {\n                            deepDelete(this.addedSet, n);\n                            this.droppedSet.add(n);\n                        }\n                        else if (this.addedSet.has(m.target) && nodeId === -1) ;\n                        else if (isAncestorRemoved(m.target, this.mirror)) ;\n                        else if (this.movedSet.has(n) &&\n                            this.movedMap[moveKey(nodeId, parentId)]) {\n                            deepDelete(this.movedSet, n);\n                        }\n                        else {\n                            this.removes.push({\n                                parentId,\n                                id: nodeId,\n                                isShadow: isShadowRoot(m.target) && isNativeShadowDom(m.target)\n                                    ? true\n                                    : undefined,\n                            });\n                        }\n                        this.mapRemoves.push(n);\n                    });\n                    break;\n                }\n            }\n        };\n        this.genAdds = (n, target) => {\n            if (this.processedNodeManager.inOtherBuffer(n, this))\n                return;\n            if (this.addedSet.has(n) || this.movedSet.has(n))\n                return;\n            if (this.mirror.hasNode(n)) {\n                if (isIgnored(n, this.mirror)) {\n                    return;\n                }\n                this.movedSet.add(n);\n                let targetId = null;\n                if (target && this.mirror.hasNode(target)) {\n                    targetId = this.mirror.getId(target);\n                }\n                if (targetId && targetId !== -1) {\n                    this.movedMap[moveKey(this.mirror.getId(n), targetId)] = true;\n                }\n            }\n            else {\n                this.addedSet.add(n);\n                this.droppedSet.delete(n);\n            }\n            if (!isBlocked(n, this.blockClass, this.blockSelector, this.unblockSelector, false)) {\n                n.childNodes.forEach((childN) => this.genAdds(childN));\n                if (hasShadowRoot(n)) {\n                    n.shadowRoot.childNodes.forEach((childN) => {\n                        this.processedNodeManager.add(childN, this);\n                        this.genAdds(childN, n);\n                    });\n                }\n            }\n        };\n    }\n    init(options) {\n        [\n            'mutationCb',\n            'blockClass',\n            'blockSelector',\n            'unblockSelector',\n            'maskAllText',\n            'maskTextClass',\n            'unmaskTextClass',\n            'maskTextSelector',\n            'unmaskTextSelector',\n            'inlineStylesheet',\n            'maskInputOptions',\n            'maskAttributeFn',\n            'maskTextFn',\n            'maskInputFn',\n            'keepIframeSrcFn',\n            'recordCanvas',\n            'inlineImages',\n            'slimDOMOptions',\n            'dataURLOptions',\n            'doc',\n            'mirror',\n            'iframeManager',\n            'stylesheetManager',\n            'shadowDomManager',\n            'canvasManager',\n            'processedNodeManager',\n        ].forEach((key) => {\n            this[key] = options[key];\n        });\n    }\n    freeze() {\n        this.frozen = true;\n        this.canvasManager.freeze();\n    }\n    unfreeze() {\n        this.frozen = false;\n        this.canvasManager.unfreeze();\n        this.emit();\n    }\n    isFrozen() {\n        return this.frozen;\n    }\n    lock() {\n        this.locked = true;\n        this.canvasManager.lock();\n    }\n    unlock() {\n        this.locked = false;\n        this.canvasManager.unlock();\n        this.emit();\n    }\n    reset() {\n        this.shadowDomManager.reset();\n        this.canvasManager.reset();\n    }\n}\nfunction deepDelete(addsSet, n) {\n    addsSet.delete(n);\n    n.childNodes.forEach((childN) => deepDelete(addsSet, childN));\n}\nfunction isParentRemoved(removes, n, mirror) {\n    if (removes.length === 0)\n        return false;\n    return _isParentRemoved(removes, n, mirror);\n}\nfunction _isParentRemoved(removes, n, mirror) {\n    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\nfunction _optionalChain$2(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }\nconst mutationBuffers = [];\nfunction getEventTarget(event) {\n    try {\n        if ('composedPath' in event) {\n            const path = event.composedPath();\n            if (path.length) {\n                return path[0];\n            }\n        }\n        else if ('path' in event && event.path.length) {\n            return event.path[0];\n        }\n    }\n    catch (e2) {\n    }\n    return event && event.target;\n}\nfunction initMutationObserver(options, rootEl) {\n    const mutationBuffer = new MutationBuffer();\n    mutationBuffers.push(mutationBuffer);\n    mutationBuffer.init(options);\n    let mutationObserverCtor = window.MutationObserver ||\n        window.__rrMutationObserver;\n    const angularZoneSymbol = _optionalChain$2([window, 'optionalAccess', _ => _.Zone, 'optionalAccess', _2 => _2.__symbol__, 'optionalCall', _3 => _3('MutationObserver')]);\n    if (angularZoneSymbol &&\n        window[angularZoneSymbol]) {\n        mutationObserverCtor = window[angularZoneSymbol];\n    }\n    const observer = new mutationObserverCtor(callbackWrapper((mutations) => {\n        if (options.onMutation && options.onMutation(mutations) === false) {\n            return;\n        }\n        mutationBuffer.processMutations.bind(mutationBuffer)(mutations);\n    }));\n    observer.observe(rootEl, {\n        attributes: true,\n        attributeOldValue: true,\n        characterData: true,\n        characterDataOldValue: true,\n        childList: true,\n        subtree: true,\n    });\n    return observer;\n}\nfunction initMoveObserver({ mousemoveCb, sampling, doc, mirror, }) {\n    if (sampling.mousemove === false) {\n        return () => {\n        };\n    }\n    const threshold = typeof sampling.mousemove === 'number' ? sampling.mousemove : 50;\n    const callbackThreshold = typeof sampling.mousemoveCallback === 'number'\n        ? sampling.mousemoveCallback\n        : 500;\n    let positions = [];\n    let timeBaseline;\n    const wrappedCb = throttle$1(callbackWrapper((source) => {\n        const totalOffset = Date.now() - timeBaseline;\n        mousemoveCb(positions.map((p) => {\n            p.timeOffset -= totalOffset;\n            return p;\n        }), source);\n        positions = [];\n        timeBaseline = null;\n    }), callbackThreshold);\n    const updatePosition = callbackWrapper(throttle$1(callbackWrapper((evt) => {\n        const target = getEventTarget(evt);\n        const { clientX, clientY } = legacy_isTouchEvent(evt)\n            ? evt.changedTouches[0]\n            : evt;\n        if (!timeBaseline) {\n            timeBaseline = nowTimestamp();\n        }\n        positions.push({\n            x: clientX,\n            y: clientY,\n            id: mirror.getId(target),\n            timeOffset: nowTimestamp() - timeBaseline,\n        });\n        wrappedCb(typeof DragEvent !== 'undefined' && evt instanceof DragEvent\n            ? IncrementalSource.Drag\n            : evt instanceof MouseEvent\n                ? IncrementalSource.MouseMove\n                : IncrementalSource.TouchMove);\n    }), threshold, {\n        trailing: false,\n    }));\n    const handlers = [\n        on('mousemove', updatePosition, doc),\n        on('touchmove', updatePosition, doc),\n        on('drag', updatePosition, doc),\n    ];\n    return callbackWrapper(() => {\n        handlers.forEach((h) => h());\n    });\n}\nfunction initMouseInteractionObserver({ mouseInteractionCb, doc, mirror, blockClass, blockSelector, unblockSelector, sampling, }) {\n    if (sampling.mouseInteraction === false) {\n        return () => {\n        };\n    }\n    const disableMap = sampling.mouseInteraction === true ||\n        sampling.mouseInteraction === undefined\n        ? {}\n        : sampling.mouseInteraction;\n    const handlers = [];\n    let currentPointerType = null;\n    const getHandler = (eventKey) => {\n        return (event) => {\n            const target = getEventTarget(event);\n            if (isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\n                return;\n            }\n            let pointerType = null;\n            let thisEventKey = eventKey;\n            if ('pointerType' in event) {\n                switch (event.pointerType) {\n                    case 'mouse':\n                        pointerType = PointerTypes.Mouse;\n                        break;\n                    case 'touch':\n                        pointerType = PointerTypes.Touch;\n                        break;\n                    case 'pen':\n                        pointerType = PointerTypes.Pen;\n                        break;\n                }\n                if (pointerType === PointerTypes.Touch) {\n                    if (MouseInteractions[eventKey] === MouseInteractions.MouseDown) {\n                        thisEventKey = 'TouchStart';\n                    }\n                    else if (MouseInteractions[eventKey] === MouseInteractions.MouseUp) {\n                        thisEventKey = 'TouchEnd';\n                    }\n                }\n                else if (pointerType === PointerTypes.Pen) ;\n            }\n            else if (legacy_isTouchEvent(event)) {\n                pointerType = PointerTypes.Touch;\n            }\n            if (pointerType !== null) {\n                currentPointerType = pointerType;\n                if ((thisEventKey.startsWith('Touch') &&\n                    pointerType === PointerTypes.Touch) ||\n                    (thisEventKey.startsWith('Mouse') &&\n                        pointerType === PointerTypes.Mouse)) {\n                    pointerType = null;\n                }\n            }\n            else if (MouseInteractions[eventKey] === MouseInteractions.Click) {\n                pointerType = currentPointerType;\n                currentPointerType = null;\n            }\n            const e = legacy_isTouchEvent(event) ? event.changedTouches[0] : event;\n            if (!e) {\n                return;\n            }\n            const id = mirror.getId(target);\n            const { clientX, clientY } = e;\n            callbackWrapper(mouseInteractionCb)({\n                type: MouseInteractions[thisEventKey],\n                id,\n                x: clientX,\n                y: clientY,\n                ...(pointerType !== null && { pointerType }),\n            });\n        };\n    };\n    Object.keys(MouseInteractions)\n        .filter((key) => Number.isNaN(Number(key)) &&\n        !key.endsWith('_Departed') &&\n        disableMap[key] !== false)\n        .forEach((eventKey) => {\n        let eventName = toLowerCase(eventKey);\n        const handler = getHandler(eventKey);\n        if (window.PointerEvent) {\n            switch (MouseInteractions[eventKey]) {\n                case MouseInteractions.MouseDown:\n                case MouseInteractions.MouseUp:\n                    eventName = eventName.replace('mouse', 'pointer');\n                    break;\n                case MouseInteractions.TouchStart:\n                case MouseInteractions.TouchEnd:\n                    return;\n            }\n        }\n        handlers.push(on(eventName, handler, doc));\n    });\n    return callbackWrapper(() => {\n        handlers.forEach((h) => h());\n    });\n}\nfunction initScrollObserver({ scrollCb, doc, mirror, blockClass, blockSelector, unblockSelector, sampling, }) {\n    const updatePosition = callbackWrapper(throttle$1(callbackWrapper((evt) => {\n        const target = getEventTarget(evt);\n        if (!target ||\n            isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\n            return;\n        }\n        const id = mirror.getId(target);\n        if (target === doc && doc.defaultView) {\n            const scrollLeftTop = getWindowScroll(doc.defaultView);\n            scrollCb({\n                id,\n                x: scrollLeftTop.left,\n                y: scrollLeftTop.top,\n            });\n        }\n        else {\n            scrollCb({\n                id,\n                x: target.scrollLeft,\n                y: target.scrollTop,\n            });\n        }\n    }), sampling.scroll || 100));\n    return on('scroll', updatePosition, doc);\n}\nfunction initViewportResizeObserver({ viewportResizeCb }, { win }) {\n    let lastH = -1;\n    let lastW = -1;\n    const updateDimension = callbackWrapper(throttle$1(callbackWrapper(() => {\n        const height = getWindowHeight();\n        const width = getWindowWidth();\n        if (lastH !== height || lastW !== width) {\n            viewportResizeCb({\n                width: Number(width),\n                height: Number(height),\n            });\n            lastH = height;\n            lastW = width;\n        }\n    }), 200));\n    return on('resize', updateDimension, win);\n}\nconst INPUT_TAGS = ['INPUT', 'TEXTAREA', 'SELECT'];\nconst lastInputValueMap = new WeakMap();\nfunction initInputObserver({ inputCb, doc, mirror, blockClass, blockSelector, unblockSelector, ignoreClass, ignoreSelector, maskInputOptions, maskInputFn, sampling, userTriggeredOnInput, maskTextClass, unmaskTextClass, maskTextSelector, unmaskTextSelector, }) {\n    function eventHandler(event) {\n        let target = getEventTarget(event);\n        const userTriggered = event.isTrusted;\n        const tagName = target && toUpperCase(target.tagName);\n        if (tagName === 'OPTION')\n            target = target.parentElement;\n        if (!target ||\n            !tagName ||\n            INPUT_TAGS.indexOf(tagName) < 0 ||\n            isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\n            return;\n        }\n        const el = target;\n        if (el.classList.contains(ignoreClass) ||\n            (ignoreSelector && el.matches(ignoreSelector))) {\n            return;\n        }\n        const type = getInputType(target);\n        let text = getInputValue(el, tagName, type);\n        let isChecked = false;\n        const isInputMasked = shouldMaskInput({\n            maskInputOptions,\n            tagName,\n            type,\n        });\n        const forceMask = needMaskingText(target, maskTextClass, maskTextSelector, unmaskTextClass, unmaskTextSelector, isInputMasked);\n        if (type === 'radio' || type === 'checkbox') {\n            isChecked = target.checked;\n        }\n        text = maskInputValue({\n            isMasked: forceMask,\n            element: target,\n            value: text,\n            maskInputFn,\n        });\n        cbWithDedup(target, userTriggeredOnInput\n            ? { text, isChecked, userTriggered }\n            : { text, isChecked });\n        const name = target.name;\n        if (type === 'radio' && name && isChecked) {\n            doc\n                .querySelectorAll(`input[type=\"radio\"][name=\"${name}\"]`)\n                .forEach((el) => {\n                if (el !== target) {\n                    const text = maskInputValue({\n                        isMasked: forceMask,\n                        element: el,\n                        value: getInputValue(el, tagName, type),\n                        maskInputFn,\n                    });\n                    cbWithDedup(el, userTriggeredOnInput\n                        ? { text, isChecked: !isChecked, userTriggered: false }\n                        : { text, isChecked: !isChecked });\n                }\n            });\n        }\n    }\n    function cbWithDedup(target, v) {\n        const lastInputValue = lastInputValueMap.get(target);\n        if (!lastInputValue ||\n            lastInputValue.text !== v.text ||\n            lastInputValue.isChecked !== v.isChecked) {\n            lastInputValueMap.set(target, v);\n            const id = mirror.getId(target);\n            callbackWrapper(inputCb)({\n                ...v,\n                id,\n            });\n        }\n    }\n    const events = sampling.input === 'last' ? ['change'] : ['input', 'change'];\n    const handlers = events.map((eventName) => on(eventName, callbackWrapper(eventHandler), doc));\n    const currentWindow = doc.defaultView;\n    if (!currentWindow) {\n        return () => {\n            handlers.forEach((h) => h());\n        };\n    }\n    const propertyDescriptor = currentWindow.Object.getOwnPropertyDescriptor(currentWindow.HTMLInputElement.prototype, 'value');\n    const hookProperties = [\n        [currentWindow.HTMLInputElement.prototype, 'value'],\n        [currentWindow.HTMLInputElement.prototype, 'checked'],\n        [currentWindow.HTMLSelectElement.prototype, 'value'],\n        [currentWindow.HTMLTextAreaElement.prototype, 'value'],\n        [currentWindow.HTMLSelectElement.prototype, 'selectedIndex'],\n        [currentWindow.HTMLOptionElement.prototype, 'selected'],\n    ];\n    if (propertyDescriptor && propertyDescriptor.set) {\n        handlers.push(...hookProperties.map((p) => hookSetter(p[0], p[1], {\n            set() {\n                callbackWrapper(eventHandler)({\n                    target: this,\n                    isTrusted: false,\n                });\n            },\n        }, false, currentWindow)));\n    }\n    return callbackWrapper(() => {\n        handlers.forEach((h) => h());\n    });\n}\nfunction getNestedCSSRulePositions(rule) {\n    const positions = [];\n    function recurse(childRule, pos) {\n        if ((hasNestedCSSRule('CSSGroupingRule') &&\n            childRule.parentRule instanceof CSSGroupingRule) ||\n            (hasNestedCSSRule('CSSMediaRule') &&\n                childRule.parentRule instanceof CSSMediaRule) ||\n            (hasNestedCSSRule('CSSSupportsRule') &&\n                childRule.parentRule instanceof CSSSupportsRule) ||\n            (hasNestedCSSRule('CSSConditionRule') &&\n                childRule.parentRule instanceof CSSConditionRule)) {\n            const rules = Array.from(childRule.parentRule.cssRules);\n            const index = rules.indexOf(childRule);\n            pos.unshift(index);\n        }\n        else if (childRule.parentStyleSheet) {\n            const rules = Array.from(childRule.parentStyleSheet.cssRules);\n            const index = rules.indexOf(childRule);\n            pos.unshift(index);\n        }\n        return pos;\n    }\n    return recurse(rule, positions);\n}\nfunction getIdAndStyleId(sheet, mirror, styleMirror) {\n    let id, styleId;\n    if (!sheet)\n        return {};\n    if (sheet.ownerNode)\n        id = mirror.getId(sheet.ownerNode);\n    else\n        styleId = styleMirror.getId(sheet);\n    return {\n        styleId,\n        id,\n    };\n}\nfunction initStyleSheetObserver({ styleSheetRuleCb, mirror, stylesheetManager }, { win }) {\n    if (!win.CSSStyleSheet || !win.CSSStyleSheet.prototype) {\n        return () => {\n        };\n    }\n    const insertRule = win.CSSStyleSheet.prototype.insertRule;\n    win.CSSStyleSheet.prototype.insertRule = new Proxy(insertRule, {\n        apply: callbackWrapper((target, thisArg, argumentsList) => {\n            const [rule, index] = argumentsList;\n            const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\n            if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                styleSheetRuleCb({\n                    id,\n                    styleId,\n                    adds: [{ rule, index }],\n                });\n            }\n            return target.apply(thisArg, argumentsList);\n        }),\n    });\n    const deleteRule = win.CSSStyleSheet.prototype.deleteRule;\n    win.CSSStyleSheet.prototype.deleteRule = new Proxy(deleteRule, {\n        apply: callbackWrapper((target, thisArg, argumentsList) => {\n            const [index] = argumentsList;\n            const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\n            if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                styleSheetRuleCb({\n                    id,\n                    styleId,\n                    removes: [{ index }],\n                });\n            }\n            return target.apply(thisArg, argumentsList);\n        }),\n    });\n    let replace;\n    if (win.CSSStyleSheet.prototype.replace) {\n        replace = win.CSSStyleSheet.prototype.replace;\n        win.CSSStyleSheet.prototype.replace = new Proxy(replace, {\n            apply: callbackWrapper((target, thisArg, argumentsList) => {\n                const [text] = argumentsList;\n                const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\n                if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                    styleSheetRuleCb({\n                        id,\n                        styleId,\n                        replace: text,\n                    });\n                }\n                return target.apply(thisArg, argumentsList);\n            }),\n        });\n    }\n    let replaceSync;\n    if (win.CSSStyleSheet.prototype.replaceSync) {\n        replaceSync = win.CSSStyleSheet.prototype.replaceSync;\n        win.CSSStyleSheet.prototype.replaceSync = new Proxy(replaceSync, {\n            apply: callbackWrapper((target, thisArg, argumentsList) => {\n                const [text] = argumentsList;\n                const { id, styleId } = getIdAndStyleId(thisArg, mirror, stylesheetManager.styleMirror);\n                if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                    styleSheetRuleCb({\n                        id,\n                        styleId,\n                        replaceSync: text,\n                    });\n                }\n                return target.apply(thisArg, argumentsList);\n            }),\n        });\n    }\n    const supportedNestedCSSRuleTypes = {};\n    if (canMonkeyPatchNestedCSSRule('CSSGroupingRule')) {\n        supportedNestedCSSRuleTypes.CSSGroupingRule = win.CSSGroupingRule;\n    }\n    else {\n        if (canMonkeyPatchNestedCSSRule('CSSMediaRule')) {\n            supportedNestedCSSRuleTypes.CSSMediaRule = win.CSSMediaRule;\n        }\n        if (canMonkeyPatchNestedCSSRule('CSSConditionRule')) {\n            supportedNestedCSSRuleTypes.CSSConditionRule = win.CSSConditionRule;\n        }\n        if (canMonkeyPatchNestedCSSRule('CSSSupportsRule')) {\n            supportedNestedCSSRuleTypes.CSSSupportsRule = win.CSSSupportsRule;\n        }\n    }\n    const unmodifiedFunctions = {};\n    Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {\n        unmodifiedFunctions[typeKey] = {\n            insertRule: type.prototype.insertRule,\n            deleteRule: type.prototype.deleteRule,\n        };\n        type.prototype.insertRule = new Proxy(unmodifiedFunctions[typeKey].insertRule, {\n            apply: callbackWrapper((target, thisArg, argumentsList) => {\n                const [rule, index] = argumentsList;\n                const { id, styleId } = getIdAndStyleId(thisArg.parentStyleSheet, mirror, stylesheetManager.styleMirror);\n                if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                    styleSheetRuleCb({\n                        id,\n                        styleId,\n                        adds: [\n                            {\n                                rule,\n                                index: [\n                                    ...getNestedCSSRulePositions(thisArg),\n                                    index || 0,\n                                ],\n                            },\n                        ],\n                    });\n                }\n                return target.apply(thisArg, argumentsList);\n            }),\n        });\n        type.prototype.deleteRule = new Proxy(unmodifiedFunctions[typeKey].deleteRule, {\n            apply: callbackWrapper((target, thisArg, argumentsList) => {\n                const [index] = argumentsList;\n                const { id, styleId } = getIdAndStyleId(thisArg.parentStyleSheet, mirror, stylesheetManager.styleMirror);\n                if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                    styleSheetRuleCb({\n                        id,\n                        styleId,\n                        removes: [\n                            { index: [...getNestedCSSRulePositions(thisArg), index] },\n                        ],\n                    });\n                }\n                return target.apply(thisArg, argumentsList);\n            }),\n        });\n    });\n    return callbackWrapper(() => {\n        win.CSSStyleSheet.prototype.insertRule = insertRule;\n        win.CSSStyleSheet.prototype.deleteRule = deleteRule;\n        replace && (win.CSSStyleSheet.prototype.replace = replace);\n        replaceSync && (win.CSSStyleSheet.prototype.replaceSync = replaceSync);\n        Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {\n            type.prototype.insertRule = unmodifiedFunctions[typeKey].insertRule;\n            type.prototype.deleteRule = unmodifiedFunctions[typeKey].deleteRule;\n        });\n    });\n}\nfunction initAdoptedStyleSheetObserver({ mirror, stylesheetManager, }, host) {\n    let hostId = null;\n    if (host.nodeName === '#document')\n        hostId = mirror.getId(host);\n    else\n        hostId = mirror.getId(host.host);\n    const patchTarget = host.nodeName === '#document'\n        ? _optionalChain$2([host, 'access', _4 => _4.defaultView, 'optionalAccess', _5 => _5.Document])\n        : _optionalChain$2([host, 'access', _6 => _6.ownerDocument, 'optionalAccess', _7 => _7.defaultView, 'optionalAccess', _8 => _8.ShadowRoot]);\n    const originalPropertyDescriptor = _optionalChain$2([patchTarget, 'optionalAccess', _9 => _9.prototype])\n        ? Object.getOwnPropertyDescriptor(_optionalChain$2([patchTarget, 'optionalAccess', _10 => _10.prototype]), 'adoptedStyleSheets')\n        : undefined;\n    if (hostId === null ||\n        hostId === -1 ||\n        !patchTarget ||\n        !originalPropertyDescriptor)\n        return () => {\n        };\n    Object.defineProperty(host, 'adoptedStyleSheets', {\n        configurable: originalPropertyDescriptor.configurable,\n        enumerable: originalPropertyDescriptor.enumerable,\n        get() {\n            return _optionalChain$2([originalPropertyDescriptor, 'access', _11 => _11.get, 'optionalAccess', _12 => _12.call, 'call', _13 => _13(this)]);\n        },\n        set(sheets) {\n            const result = _optionalChain$2([originalPropertyDescriptor, 'access', _14 => _14.set, 'optionalAccess', _15 => _15.call, 'call', _16 => _16(this, sheets)]);\n            if (hostId !== null && hostId !== -1) {\n                try {\n                    stylesheetManager.adoptStyleSheets(sheets, hostId);\n                }\n                catch (e) {\n                }\n            }\n            return result;\n        },\n    });\n    return callbackWrapper(() => {\n        Object.defineProperty(host, 'adoptedStyleSheets', {\n            configurable: originalPropertyDescriptor.configurable,\n            enumerable: originalPropertyDescriptor.enumerable,\n            get: originalPropertyDescriptor.get,\n            set: originalPropertyDescriptor.set,\n        });\n    });\n}\nfunction initStyleDeclarationObserver({ styleDeclarationCb, mirror, ignoreCSSAttributes, stylesheetManager, }, { win }) {\n    const setProperty = win.CSSStyleDeclaration.prototype.setProperty;\n    win.CSSStyleDeclaration.prototype.setProperty = new Proxy(setProperty, {\n        apply: callbackWrapper((target, thisArg, argumentsList) => {\n            const [property, value, priority] = argumentsList;\n            if (ignoreCSSAttributes.has(property)) {\n                return setProperty.apply(thisArg, [property, value, priority]);\n            }\n            const { id, styleId } = getIdAndStyleId(_optionalChain$2([thisArg, 'access', _17 => _17.parentRule, 'optionalAccess', _18 => _18.parentStyleSheet]), mirror, stylesheetManager.styleMirror);\n            if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                styleDeclarationCb({\n                    id,\n                    styleId,\n                    set: {\n                        property,\n                        value,\n                        priority,\n                    },\n                    index: getNestedCSSRulePositions(thisArg.parentRule),\n                });\n            }\n            return target.apply(thisArg, argumentsList);\n        }),\n    });\n    const removeProperty = win.CSSStyleDeclaration.prototype.removeProperty;\n    win.CSSStyleDeclaration.prototype.removeProperty = new Proxy(removeProperty, {\n        apply: callbackWrapper((target, thisArg, argumentsList) => {\n            const [property] = argumentsList;\n            if (ignoreCSSAttributes.has(property)) {\n                return removeProperty.apply(thisArg, [property]);\n            }\n            const { id, styleId } = getIdAndStyleId(_optionalChain$2([thisArg, 'access', _19 => _19.parentRule, 'optionalAccess', _20 => _20.parentStyleSheet]), mirror, stylesheetManager.styleMirror);\n            if ((id && id !== -1) || (styleId && styleId !== -1)) {\n                styleDeclarationCb({\n                    id,\n                    styleId,\n                    remove: {\n                        property,\n                    },\n                    index: getNestedCSSRulePositions(thisArg.parentRule),\n                });\n            }\n            return target.apply(thisArg, argumentsList);\n        }),\n    });\n    return callbackWrapper(() => {\n        win.CSSStyleDeclaration.prototype.setProperty = setProperty;\n        win.CSSStyleDeclaration.prototype.removeProperty = removeProperty;\n    });\n}\nfunction initMediaInteractionObserver({ mediaInteractionCb, blockClass, blockSelector, unblockSelector, mirror, sampling, doc, }) {\n    const handler = callbackWrapper((type) => throttle$1(callbackWrapper((event) => {\n        const target = getEventTarget(event);\n        if (!target ||\n            isBlocked(target, blockClass, blockSelector, unblockSelector, true)) {\n            return;\n        }\n        const { currentTime, volume, muted, playbackRate } = target;\n        mediaInteractionCb({\n            type,\n            id: mirror.getId(target),\n            currentTime,\n            volume,\n            muted,\n            playbackRate,\n        });\n    }), sampling.media || 500));\n    const handlers = [\n        on('play', handler(0), doc),\n        on('pause', handler(1), doc),\n        on('seeked', handler(2), doc),\n        on('volumechange', handler(3), doc),\n        on('ratechange', handler(4), doc),\n    ];\n    return callbackWrapper(() => {\n        handlers.forEach((h) => h());\n    });\n}\nfunction initFontObserver({ fontCb, doc }) {\n    const win = doc.defaultView;\n    if (!win) {\n        return () => {\n        };\n    }\n    const handlers = [];\n    const fontMap = new WeakMap();\n    const originalFontFace = win.FontFace;\n    win.FontFace = function FontFace(family, source, descriptors) {\n        const fontFace = new originalFontFace(family, source, descriptors);\n        fontMap.set(fontFace, {\n            family,\n            buffer: typeof source !== 'string',\n            descriptors,\n            fontSource: typeof source === 'string'\n                ? source\n                : JSON.stringify(Array.from(new Uint8Array(source))),\n        });\n        return fontFace;\n    };\n    const restoreHandler = patch(doc.fonts, 'add', function (original) {\n        return function (fontFace) {\n            setTimeout$1(callbackWrapper(() => {\n                const p = fontMap.get(fontFace);\n                if (p) {\n                    fontCb(p);\n                    fontMap.delete(fontFace);\n                }\n            }), 0);\n            return original.apply(this, [fontFace]);\n        };\n    });\n    handlers.push(() => {\n        win.FontFace = originalFontFace;\n    });\n    handlers.push(restoreHandler);\n    return callbackWrapper(() => {\n        handlers.forEach((h) => h());\n    });\n}\nfunction initSelectionObserver(param) {\n    const { doc, mirror, blockClass, blockSelector, unblockSelector, selectionCb, } = param;\n    let collapsed = true;\n    const updateSelection = callbackWrapper(() => {\n        const selection = doc.getSelection();\n        if (!selection || (collapsed && _optionalChain$2([selection, 'optionalAccess', _21 => _21.isCollapsed])))\n            return;\n        collapsed = selection.isCollapsed || false;\n        const ranges = [];\n        const count = selection.rangeCount || 0;\n        for (let i = 0; i < count; i++) {\n            const range = selection.getRangeAt(i);\n            const { startContainer, startOffset, endContainer, endOffset } = range;\n            const blocked = isBlocked(startContainer, blockClass, blockSelector, unblockSelector, true) ||\n                isBlocked(endContainer, blockClass, blockSelector, unblockSelector, true);\n            if (blocked)\n                continue;\n            ranges.push({\n                start: mirror.getId(startContainer),\n                startOffset,\n                end: mirror.getId(endContainer),\n                endOffset,\n            });\n        }\n        selectionCb({ ranges });\n    });\n    updateSelection();\n    return on('selectionchange', updateSelection);\n}\nfunction initCustomElementObserver({ doc, customElementCb, }) {\n    const win = doc.defaultView;\n    if (!win || !win.customElements)\n        return () => { };\n    const restoreHandler = patch(win.customElements, 'define', function (original) {\n        return function (name, constructor, options) {\n            try {\n                customElementCb({\n                    define: {\n                        name,\n                    },\n                });\n            }\n            catch (e) {\n            }\n            return original.apply(this, [name, constructor, options]);\n        };\n    });\n    return restoreHandler;\n}\nfunction initObservers(o, _hooks = {}) {\n    const currentWindow = o.doc.defaultView;\n    if (!currentWindow) {\n        return () => {\n        };\n    }\n    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    const pluginHandlers = [];\n    for (const plugin of o.plugins) {\n        pluginHandlers.push(plugin.observer(plugin.callback, currentWindow, plugin.options));\n    }\n    return callbackWrapper(() => {\n        mutationBuffers.forEach((b) => b.reset());\n        mutationObserver.disconnect();\n        mousemoveHandler();\n        mouseInteractionHandler();\n        scrollHandler();\n        viewportResizeHandler();\n        inputHandler();\n        mediaInteractionHandler();\n        styleSheetObserver();\n        adoptedStyleSheetObserver();\n        styleDeclarationObserver();\n        fontObserver();\n        selectionObserver();\n        customElementObserver();\n        pluginHandlers.forEach((h) => h());\n    });\n}\nfunction hasNestedCSSRule(prop) {\n    return typeof window[prop] !== 'undefined';\n}\nfunction canMonkeyPatchNestedCSSRule(prop) {\n    return Boolean(typeof window[prop] !== 'undefined' &&\n        window[prop].prototype &&\n        'insertRule' in window[prop].prototype &&\n        'deleteRule' in window[prop].prototype);\n}\n\nclass CrossOriginIframeMirror {\n    constructor(generateIdFn) {\n        this.generateIdFn = generateIdFn;\n        this.iframeIdToRemoteIdMap = new WeakMap();\n        this.iframeRemoteIdToIdMap = new WeakMap();\n    }\n    getId(iframe, remoteId, idToRemoteMap, remoteToIdMap) {\n        const idToRemoteIdMap = idToRemoteMap || this.getIdToRemoteIdMap(iframe);\n        const remoteIdToIdMap = remoteToIdMap || this.getRemoteIdToIdMap(iframe);\n        let id = idToRemoteIdMap.get(remoteId);\n        if (!id) {\n            id = this.generateIdFn();\n            idToRemoteIdMap.set(remoteId, id);\n            remoteIdToIdMap.set(id, remoteId);\n        }\n        return id;\n    }\n    getIds(iframe, remoteId) {\n        const idToRemoteIdMap = this.getIdToRemoteIdMap(iframe);\n        const remoteIdToIdMap = this.getRemoteIdToIdMap(iframe);\n        return remoteId.map((id) => this.getId(iframe, id, idToRemoteIdMap, remoteIdToIdMap));\n    }\n    getRemoteId(iframe, id, map) {\n        const remoteIdToIdMap = map || this.getRemoteIdToIdMap(iframe);\n        if (typeof id !== 'number')\n            return id;\n        const remoteId = remoteIdToIdMap.get(id);\n        if (!remoteId)\n            return -1;\n        return remoteId;\n    }\n    getRemoteIds(iframe, ids) {\n        const remoteIdToIdMap = this.getRemoteIdToIdMap(iframe);\n        return ids.map((id) => this.getRemoteId(iframe, id, remoteIdToIdMap));\n    }\n    reset(iframe) {\n        if (!iframe) {\n            this.iframeIdToRemoteIdMap = new WeakMap();\n            this.iframeRemoteIdToIdMap = new WeakMap();\n            return;\n        }\n        this.iframeIdToRemoteIdMap.delete(iframe);\n        this.iframeRemoteIdToIdMap.delete(iframe);\n    }\n    getIdToRemoteIdMap(iframe) {\n        let idToRemoteIdMap = this.iframeIdToRemoteIdMap.get(iframe);\n        if (!idToRemoteIdMap) {\n            idToRemoteIdMap = new Map();\n            this.iframeIdToRemoteIdMap.set(iframe, idToRemoteIdMap);\n        }\n        return idToRemoteIdMap;\n    }\n    getRemoteIdToIdMap(iframe) {\n        let remoteIdToIdMap = this.iframeRemoteIdToIdMap.get(iframe);\n        if (!remoteIdToIdMap) {\n            remoteIdToIdMap = new Map();\n            this.iframeRemoteIdToIdMap.set(iframe, remoteIdToIdMap);\n        }\n        return remoteIdToIdMap;\n    }\n}\n\nfunction _optionalChain$1(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }\nclass IframeManagerNoop {\n    constructor() {\n        this.crossOriginIframeMirror = new CrossOriginIframeMirror(genId);\n        this.crossOriginIframeRootIdMap = new WeakMap();\n    }\n    addIframe() {\n    }\n    addLoadListener() {\n    }\n    attachIframe() {\n    }\n}\nclass IframeManager {\n    constructor(options) {\n        this.iframes = new WeakMap();\n        this.crossOriginIframeMap = new WeakMap();\n        this.crossOriginIframeMirror = new CrossOriginIframeMirror(genId);\n        this.crossOriginIframeRootIdMap = new WeakMap();\n        this.mutationCb = options.mutationCb;\n        this.wrappedEmit = options.wrappedEmit;\n        this.stylesheetManager = options.stylesheetManager;\n        this.recordCrossOriginIframes = options.recordCrossOriginIframes;\n        this.crossOriginIframeStyleMirror = new CrossOriginIframeMirror(this.stylesheetManager.styleMirror.generateId.bind(this.stylesheetManager.styleMirror));\n        this.mirror = options.mirror;\n        if (this.recordCrossOriginIframes) {\n            window.addEventListener('message', this.handleMessage.bind(this));\n        }\n    }\n    addIframe(iframeEl) {\n        this.iframes.set(iframeEl, true);\n        if (iframeEl.contentWindow)\n            this.crossOriginIframeMap.set(iframeEl.contentWindow, iframeEl);\n    }\n    addLoadListener(cb) {\n        this.loadListener = cb;\n    }\n    attachIframe(iframeEl, childSn) {\n        this.mutationCb({\n            adds: [\n                {\n                    parentId: this.mirror.getId(iframeEl),\n                    nextId: null,\n                    node: childSn,\n                },\n            ],\n            removes: [],\n            texts: [],\n            attributes: [],\n            isAttachIframe: true,\n        });\n        _optionalChain$1([this, 'access', _ => _.loadListener, 'optionalCall', _2 => _2(iframeEl)]);\n        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        switch (e.type) {\n            case EventType.FullSnapshot: {\n                this.crossOriginIframeMirror.reset(iframeEl);\n                this.crossOriginIframeStyleMirror.reset(iframeEl);\n                this.replaceIdOnNode(e.data.node, iframeEl);\n                const rootId = e.data.node.id;\n                this.crossOriginIframeRootIdMap.set(iframeEl, rootId);\n                this.patchRootIdOnNode(e.data.node, rootId);\n                return {\n                    timestamp: e.timestamp,\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.Mutation,\n                        adds: [\n                            {\n                                parentId: this.mirror.getId(iframeEl),\n                                nextId: null,\n                                node: e.data.node,\n                            },\n                        ],\n                        removes: [],\n                        texts: [],\n                        attributes: [],\n                        isAttachIframe: true,\n                    },\n                };\n            }\n            case EventType.Meta:\n            case EventType.Load:\n            case EventType.DomContentLoaded: {\n                return false;\n            }\n            case EventType.Plugin: {\n                return e;\n            }\n            case EventType.Custom: {\n                this.replaceIds(e.data.payload, iframeEl, ['id', 'parentId', 'previousId', 'nextId']);\n                return e;\n            }\n            case EventType.IncrementalSnapshot: {\n                switch (e.data.source) {\n                    case IncrementalSource.Mutation: {\n                        e.data.adds.forEach((n) => {\n                            this.replaceIds(n, iframeEl, [\n                                'parentId',\n                                'nextId',\n                                'previousId',\n                            ]);\n                            this.replaceIdOnNode(n.node, iframeEl);\n                            const rootId = this.crossOriginIframeRootIdMap.get(iframeEl);\n                            rootId && this.patchRootIdOnNode(n.node, rootId);\n                        });\n                        e.data.removes.forEach((n) => {\n                            this.replaceIds(n, iframeEl, ['parentId', 'id']);\n                        });\n                        e.data.attributes.forEach((n) => {\n                            this.replaceIds(n, iframeEl, ['id']);\n                        });\n                        e.data.texts.forEach((n) => {\n                            this.replaceIds(n, iframeEl, ['id']);\n                        });\n                        return e;\n                    }\n                    case IncrementalSource.Drag:\n                    case IncrementalSource.TouchMove:\n                    case IncrementalSource.MouseMove: {\n                        e.data.positions.forEach((p) => {\n                            this.replaceIds(p, iframeEl, ['id']);\n                        });\n                        return e;\n                    }\n                    case IncrementalSource.ViewportResize: {\n                        return false;\n                    }\n                    case IncrementalSource.MediaInteraction:\n                    case IncrementalSource.MouseInteraction:\n                    case IncrementalSource.Scroll:\n                    case IncrementalSource.CanvasMutation:\n                    case IncrementalSource.Input: {\n                        this.replaceIds(e.data, iframeEl, ['id']);\n                        return e;\n                    }\n                    case IncrementalSource.StyleSheetRule:\n                    case IncrementalSource.StyleDeclaration: {\n                        this.replaceIds(e.data, iframeEl, ['id']);\n                        this.replaceStyleIds(e.data, iframeEl, ['styleId']);\n                        return e;\n                    }\n                    case IncrementalSource.Font: {\n                        return e;\n                    }\n                    case IncrementalSource.Selection: {\n                        e.data.ranges.forEach((range) => {\n                            this.replaceIds(range, iframeEl, ['start', 'end']);\n                        });\n                        return e;\n                    }\n                    case IncrementalSource.AdoptedStyleSheet: {\n                        this.replaceIds(e.data, iframeEl, ['id']);\n                        this.replaceStyleIds(e.data, iframeEl, ['styleIds']);\n                        _optionalChain$1([e, 'access', _3 => _3.data, 'access', _4 => _4.styles, 'optionalAccess', _5 => _5.forEach, 'call', _6 => _6((style) => {\n                            this.replaceStyleIds(style, iframeEl, ['styleId']);\n                        })]);\n                        return e;\n                    }\n                }\n            }\n        }\n        return false;\n    }\n    replace(iframeMirror, obj, iframeEl, keys) {\n        for (const key of keys) {\n            if (!Array.isArray(obj[key]) && typeof obj[key] !== 'number')\n                continue;\n            if (Array.isArray(obj[key])) {\n                obj[key] = iframeMirror.getIds(iframeEl, obj[key]);\n            }\n            else {\n                obj[key] = iframeMirror.getId(iframeEl, obj[key]);\n            }\n        }\n        return obj;\n    }\n    replaceIds(obj, iframeEl, keys) {\n        return this.replace(this.crossOriginIframeMirror, obj, iframeEl, keys);\n    }\n    replaceStyleIds(obj, iframeEl, keys) {\n        return this.replace(this.crossOriginIframeStyleMirror, obj, iframeEl, keys);\n    }\n    replaceIdOnNode(node, iframeEl) {\n        this.replaceIds(node, iframeEl, ['id', 'rootId']);\n        if ('childNodes' in node) {\n            node.childNodes.forEach((child) => {\n                this.replaceIdOnNode(child, iframeEl);\n            });\n        }\n    }\n    patchRootIdOnNode(node, rootId) {\n        if (node.type !== NodeType$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({\n            ...this.bypassOptions,\n            doc,\n            mutationCb: this.mutationCb,\n            mirror: this.mirror,\n            shadowDomManager: this,\n        }, shadowRoot);\n        this.restoreHandlers.push(() => observer.disconnect());\n        this.restoreHandlers.push(initScrollObserver({\n            ...this.bypassOptions,\n            scrollCb: this.scrollCb,\n            doc: shadowRoot,\n            mirror: this.mirror,\n        }));\n        setTimeout$1(() => {\n            if (shadowRoot.adoptedStyleSheets &&\n                shadowRoot.adoptedStyleSheets.length > 0)\n                this.bypassOptions.stylesheetManager.adoptStyleSheets(shadowRoot.adoptedStyleSheets, this.mirror.getId(shadowRoot.host));\n            this.restoreHandlers.push(initAdoptedStyleSheetObserver({\n                mirror: this.mirror,\n                stylesheetManager: this.bypassOptions.stylesheetManager,\n            }, shadowRoot));\n        }, 0);\n    }\n    observeAttachShadow(iframeElement) {\n        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    snapshot() {\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        onRequestAnimationFrame(() => {\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\nlet wrappedEmit;\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, maxCanvasSize = null, packFn, sampling = {}, dataURLOptions = {}, mousemoveWait, recordCanvas = false, recordCrossOriginIframes = false, recordAfter = options.recordAfter === 'DOMContentLoaded'\n        ? options.recordAfter\n        : 'load', userTriggeredOnInput = false, collectFonts = false, inlineImages = false, plugins, keepIframeSrcFn = () => false, ignoreCSSAttributes = new Set([]), errorHandler, onMutation, getCanvasManager, } = options;\n    registerErrorHandler(errorHandler);\n    const inEmittingFrame = recordCrossOriginIframes\n        ? window.parent === window\n        : true;\n    let passEmitsToParent = false;\n    if (!inEmittingFrame) {\n        try {\n            if (window.parent.document) {\n                passEmitsToParent = false;\n            }\n        }\n        catch (e) {\n            passEmitsToParent = true;\n        }\n    }\n    if (inEmittingFrame && !emit) {\n        throw new Error('emit function is required');\n    }\n    if (mousemoveWait !== undefined && sampling.mousemove === undefined) {\n        sampling.mousemove = mousemoveWait;\n    }\n    mirror.reset();\n    const maskInputOptions = maskAllInputs === true\n        ? {\n            color: true,\n            date: true,\n            'datetime-local': true,\n            email: true,\n            month: true,\n            number: true,\n            range: true,\n            search: true,\n            tel: true,\n            text: true,\n            time: true,\n            url: true,\n            week: true,\n            textarea: true,\n            select: true,\n            radio: true,\n            checkbox: true,\n        }\n        : _maskInputOptions !== undefined\n            ? _maskInputOptions\n            : {};\n    const slimDOMOptions = _slimDOMOptions === true || _slimDOMOptions === 'all'\n        ? {\n            script: true,\n            comment: true,\n            headFavicon: true,\n            headWhitespace: true,\n            headMetaSocial: true,\n            headMetaRobots: true,\n            headMetaHttpEquiv: true,\n            headMetaVerification: true,\n            headMetaAuthorship: _slimDOMOptions === 'all',\n            headMetaDescKeywords: _slimDOMOptions === 'all',\n        }\n        : _slimDOMOptions\n            ? _slimDOMOptions\n            : {};\n    polyfill();\n    let lastFullSnapshotEvent;\n    let incrementalSnapshotCount = 0;\n    const eventProcessor = (e) => {\n        for (const plugin of plugins || []) {\n            if (plugin.eventProcessor) {\n                e = plugin.eventProcessor(e);\n            }\n        }\n        if (packFn &&\n            !passEmitsToParent) {\n            e = packFn(e);\n        }\n        return e;\n    };\n    wrappedEmit = (r, isCheckout) => {\n        const e = r;\n        e.timestamp = nowTimestamp();\n        if (_optionalChain([mutationBuffers, 'access', _ => _[0], 'optionalAccess', _2 => _2.isFrozen, 'call', _3 => _3()]) &&\n            e.type !== EventType.FullSnapshot &&\n            !(e.type === EventType.IncrementalSnapshot &&\n                e.data.source === IncrementalSource.Mutation)) {\n            mutationBuffers.forEach((buf) => buf.unfreeze());\n        }\n        if (inEmittingFrame) {\n            _optionalChain([emit, 'optionalCall', _4 => _4(eventProcessor(e), isCheckout)]);\n        }\n        else if (passEmitsToParent) {\n            const message = {\n                type: 'rrweb',\n                event: eventProcessor(e),\n                origin: window.location.origin,\n                isCheckout,\n            };\n            window.parent.postMessage(message, '*');\n        }\n        if (e.type === EventType.FullSnapshot) {\n            lastFullSnapshotEvent = e;\n            incrementalSnapshotCount = 0;\n        }\n        else if (e.type === EventType.IncrementalSnapshot) {\n            if (e.data.source === IncrementalSource.Mutation &&\n                e.data.isAttachIframe) {\n                return;\n            }\n            incrementalSnapshotCount++;\n            const exceedCount = checkoutEveryNth && incrementalSnapshotCount >= checkoutEveryNth;\n            const exceedTime = checkoutEveryNms &&\n                lastFullSnapshotEvent &&\n                e.timestamp - lastFullSnapshotEvent.timestamp > checkoutEveryNms;\n            if (exceedCount || exceedTime) {\n                takeFullSnapshot(true);\n            }\n        }\n    };\n    const wrappedMutationEmit = (m) => {\n        wrappedEmit({\n            type: EventType.IncrementalSnapshot,\n            data: {\n                source: IncrementalSource.Mutation,\n                ...m,\n            },\n        });\n    };\n    const wrappedScrollEmit = (p) => wrappedEmit({\n        type: EventType.IncrementalSnapshot,\n        data: {\n            source: IncrementalSource.Scroll,\n            ...p,\n        },\n    });\n    const wrappedCanvasMutationEmit = (p) => wrappedEmit({\n        type: EventType.IncrementalSnapshot,\n        data: {\n            source: IncrementalSource.CanvasMutation,\n            ...p,\n        },\n    });\n    const wrappedAdoptedStyleSheetEmit = (a) => wrappedEmit({\n        type: EventType.IncrementalSnapshot,\n        data: {\n            source: IncrementalSource.AdoptedStyleSheet,\n            ...a,\n        },\n    });\n    const stylesheetManager = new StylesheetManager({\n        mutationCb: wrappedMutationEmit,\n        adoptedStyleSheetCb: wrappedAdoptedStyleSheetEmit,\n    });\n    const iframeManager = typeof __RRWEB_EXCLUDE_IFRAME__ === 'boolean' && __RRWEB_EXCLUDE_IFRAME__\n        ? new IframeManagerNoop()\n        : new IframeManager({\n            mirror,\n            mutationCb: wrappedMutationEmit,\n            stylesheetManager: stylesheetManager,\n            recordCrossOriginIframes,\n            wrappedEmit,\n        });\n    for (const plugin of plugins || []) {\n        if (plugin.getMirror)\n            plugin.getMirror({\n                nodeMirror: mirror,\n                crossOriginIframeMirror: iframeManager.crossOriginIframeMirror,\n                crossOriginIframeStyleMirror: iframeManager.crossOriginIframeStyleMirror,\n            });\n    }\n    const processedNodeManager = new ProcessedNodeManager();\n    const canvasManager = _getCanvasManager(getCanvasManager, {\n        mirror,\n        win: window,\n        mutationCb: (p) => wrappedEmit({\n            type: EventType.IncrementalSnapshot,\n            data: {\n                source: IncrementalSource.CanvasMutation,\n                ...p,\n            },\n        }),\n        recordCanvas,\n        blockClass,\n        blockSelector,\n        unblockSelector,\n        maxCanvasSize,\n        sampling: sampling['canvas'],\n        dataURLOptions,\n        errorHandler,\n    });\n    const shadowDomManager = typeof __RRWEB_EXCLUDE_SHADOW_DOM__ === 'boolean' &&\n        __RRWEB_EXCLUDE_SHADOW_DOM__\n        ? new ShadowDomManagerNoop()\n        : new ShadowDomManager({\n            mutationCb: wrappedMutationEmit,\n            scrollCb: wrappedScrollEmit,\n            bypassOptions: {\n                onMutation,\n                blockClass,\n                blockSelector,\n                unblockSelector,\n                maskAllText,\n                maskTextClass,\n                unmaskTextClass,\n                maskTextSelector,\n                unmaskTextSelector,\n                inlineStylesheet,\n                maskInputOptions,\n                dataURLOptions,\n                maskAttributeFn,\n                maskTextFn,\n                maskInputFn,\n                recordCanvas,\n                inlineImages,\n                sampling,\n                slimDOMOptions,\n                iframeManager,\n                stylesheetManager,\n                canvasManager,\n                keepIframeSrcFn,\n                processedNodeManager,\n            },\n            mirror,\n        });\n    const takeFullSnapshot = (isCheckout = false) => {\n        wrappedEmit({\n            type: EventType.Meta,\n            data: {\n                href: window.location.href,\n                width: getWindowWidth(),\n                height: getWindowHeight(),\n            },\n        }, isCheckout);\n        stylesheetManager.reset();\n        shadowDomManager.init();\n        mutationBuffers.forEach((buf) => buf.lock());\n        const node = snapshot(document, {\n            mirror,\n            blockClass,\n            blockSelector,\n            unblockSelector,\n            maskAllText,\n            maskTextClass,\n            unmaskTextClass,\n            maskTextSelector,\n            unmaskTextSelector,\n            inlineStylesheet,\n            maskAllInputs: maskInputOptions,\n            maskAttributeFn,\n            maskInputFn,\n            maskTextFn,\n            slimDOM: slimDOMOptions,\n            dataURLOptions,\n            recordCanvas,\n            inlineImages,\n            onSerialize: (n) => {\n                if (isSerializedIframe(n, mirror)) {\n                    iframeManager.addIframe(n);\n                }\n                if (isSerializedStylesheet(n, mirror)) {\n                    stylesheetManager.trackLinkElement(n);\n                }\n                if (hasShadowRoot(n)) {\n                    shadowDomManager.addShadowRoot(n.shadowRoot, document);\n                }\n            },\n            onIframeLoad: (iframe, childSn) => {\n                iframeManager.attachIframe(iframe, childSn);\n                shadowDomManager.observeAttachShadow(iframe);\n            },\n            onStylesheetLoad: (linkEl, childSn) => {\n                stylesheetManager.attachLinkElement(linkEl, childSn);\n            },\n            keepIframeSrcFn,\n        });\n        if (!node) {\n            return console.warn('Failed to snapshot the document');\n        }\n        wrappedEmit({\n            type: EventType.FullSnapshot,\n            data: {\n                node,\n                initialOffset: getWindowScroll(window),\n            },\n        });\n        mutationBuffers.forEach((buf) => buf.unlock());\n        if (document.adoptedStyleSheets && document.adoptedStyleSheets.length > 0)\n            stylesheetManager.adoptStyleSheets(document.adoptedStyleSheets, mirror.getId(document));\n    };\n    _takeFullSnapshot = takeFullSnapshot;\n    try {\n        const handlers = [];\n        const observe = (doc) => {\n            return callbackWrapper(initObservers)({\n                onMutation,\n                mutationCb: wrappedMutationEmit,\n                mousemoveCb: (positions, source) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source,\n                        positions,\n                    },\n                }),\n                mouseInteractionCb: (d) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.MouseInteraction,\n                        ...d,\n                    },\n                }),\n                scrollCb: wrappedScrollEmit,\n                viewportResizeCb: (d) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.ViewportResize,\n                        ...d,\n                    },\n                }),\n                inputCb: (v) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.Input,\n                        ...v,\n                    },\n                }),\n                mediaInteractionCb: (p) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.MediaInteraction,\n                        ...p,\n                    },\n                }),\n                styleSheetRuleCb: (r) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.StyleSheetRule,\n                        ...r,\n                    },\n                }),\n                styleDeclarationCb: (r) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.StyleDeclaration,\n                        ...r,\n                    },\n                }),\n                canvasMutationCb: wrappedCanvasMutationEmit,\n                fontCb: (p) => wrappedEmit({\n                    type: EventType.IncrementalSnapshot,\n                    data: {\n                        source: IncrementalSource.Font,\n                        ...p,\n                    },\n                }),\n                selectionCb: (p) => {\n                    wrappedEmit({\n                        type: EventType.IncrementalSnapshot,\n                        data: {\n                            source: IncrementalSource.Selection,\n                            ...p,\n                        },\n                    });\n                },\n                customElementCb: (c) => {\n                    wrappedEmit({\n                        type: EventType.IncrementalSnapshot,\n                        data: {\n                            source: IncrementalSource.CustomElement,\n                            ...c,\n                        },\n                    });\n                },\n                blockClass,\n                ignoreClass,\n                ignoreSelector,\n                maskAllText,\n                maskTextClass,\n                unmaskTextClass,\n                maskTextSelector,\n                unmaskTextSelector,\n                maskInputOptions,\n                inlineStylesheet,\n                sampling,\n                recordCanvas,\n                inlineImages,\n                userTriggeredOnInput,\n                collectFonts,\n                doc,\n                maskAttributeFn,\n                maskInputFn,\n                maskTextFn,\n                keepIframeSrcFn,\n                blockSelector,\n                unblockSelector,\n                slimDOMOptions,\n                dataURLOptions,\n                mirror,\n                iframeManager,\n                stylesheetManager,\n                shadowDomManager,\n                processedNodeManager,\n                canvasManager,\n                ignoreCSSAttributes,\n                plugins: _optionalChain([plugins\n, 'optionalAccess', _5 => _5.filter, 'call', _6 => _6((p) => p.observer)\n, 'optionalAccess', _7 => _7.map, 'call', _8 => _8((p) => ({\n                    observer: p.observer,\n                    options: p.options,\n                    callback: (payload) => wrappedEmit({\n                        type: EventType.Plugin,\n                        data: {\n                            plugin: p.name,\n                            payload,\n                        },\n                    }),\n                }))]) || [],\n            }, {});\n        };\n        iframeManager.addLoadListener((iframeEl) => {\n            try {\n                handlers.push(observe(iframeEl.contentDocument));\n            }\n            catch (error) {\n                console.warn(error);\n            }\n        });\n        const init = () => {\n            takeFullSnapshot();\n            handlers.push(observe(document));\n        };\n        if (document.readyState === 'interactive' ||\n            document.readyState === 'complete') {\n            init();\n        }\n        else {\n            handlers.push(on('DOMContentLoaded', () => {\n                wrappedEmit({\n                    type: EventType.DomContentLoaded,\n                    data: {},\n                });\n                if (recordAfter === 'DOMContentLoaded')\n                    init();\n            }));\n            handlers.push(on('load', () => {\n                wrappedEmit({\n                    type: EventType.Load,\n                    data: {},\n                });\n                if (recordAfter === 'load')\n                    init();\n            }, window));\n        }\n        return () => {\n            handlers.forEach((h) => h());\n            processedNodeManager.destroy();\n            _takeFullSnapshot = undefined;\n            unregisterErrorHandler();\n        };\n    }\n    catch (error) {\n        console.warn(error);\n    }\n}\nfunction takeFullSnapshot(isCheckout) {\n    if (!_takeFullSnapshot) {\n        throw new Error('please take full snapshot after start recording');\n    }\n    _takeFullSnapshot(isCheckout);\n}\nrecord.mirror = mirror;\nrecord.takeFullSnapshot = takeFullSnapshot;\nfunction _getCanvasManager(getCanvasManagerFn, options) {\n    try {\n        return getCanvasManagerFn\n            ? getCanvasManagerFn(options)\n            : new CanvasManagerNoop();\n    }\n    catch (e2) {\n        console.warn('Unable to initialize CanvasManager');\n        return new CanvasManagerNoop();\n    }\n}\n\nconst ReplayEventTypeIncrementalSnapshot = 3;\nconst ReplayEventTypeCustom = 5;\n\n/**\n * Converts a timestamp to ms, if it was in s, or keeps it as ms.\n */\nfunction timestampToMs(timestamp) {\n  const isMs = timestamp > 9999999999;\n  return isMs ? timestamp : timestamp * 1000;\n}\n\n/**\n * Converts a timestamp to s, if it was in ms, or keeps it as s.\n */\nfunction timestampToS(timestamp) {\n  const isMs = timestamp > 9999999999;\n  return isMs ? timestamp / 1000 : timestamp;\n}\n\n/**\n * Add a breadcrumb event to replay.\n */\nfunction addBreadcrumbEvent(replay, breadcrumb) {\n  if (breadcrumb.category === 'sentry.transaction') {\n    return;\n  }\n\n  if (['ui.click', 'ui.input'].includes(breadcrumb.category )) {\n    replay.triggerUserActivity();\n  } else {\n    replay.checkAndHandleExpiredSession();\n  }\n\n  replay.addUpdate(() => {\n    // This should never reject\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    replay.throttledAddEvent({\n      type: EventType.Custom,\n      // TODO: We were converting from ms to seconds for breadcrumbs, spans,\n      // but maybe we should just keep them as milliseconds\n      timestamp: (breadcrumb.timestamp || 0) * 1000,\n      data: {\n        tag: 'breadcrumb',\n        // normalize to max. 10 depth and 1_000 properties per object\n        payload: normalize(breadcrumb, 10, 1000),\n      },\n    });\n\n    // Do not flush after console log messages\n    return breadcrumb.category === 'console';\n  });\n}\n\nconst INTERACTIVE_SELECTOR = 'button,a';\n\n/** Get the closest interactive parent element, or else return the given element. */\nfunction getClosestInteractive(element) {\n  const closestInteractive = element.closest(INTERACTIVE_SELECTOR);\n  return closestInteractive || element;\n}\n\n/**\n * For clicks, we check if the target is inside of a button or link\n * If so, we use this as the target instead\n * This is useful because if you click on the image in <button><img></button>,\n * The target will be the image, not the button, which we don't want here\n */\nfunction getClickTargetNode(event) {\n  const target = getTargetNode(event);\n\n  if (!target || !(target instanceof Element)) {\n    return target;\n  }\n\n  return getClosestInteractive(target);\n}\n\n/** Get the event target node. */\nfunction getTargetNode(event) {\n  if (isEventWithTarget(event)) {\n    return event.target ;\n  }\n\n  return event;\n}\n\nfunction isEventWithTarget(event) {\n  return typeof event === 'object' && !!event && 'target' in event;\n}\n\nlet handlers;\n\n/**\n * Register a handler to be called when `window.open()` is called.\n * Returns a cleanup function.\n */\nfunction onWindowOpen(cb) {\n  // Ensure to only register this once\n  if (!handlers) {\n    handlers = [];\n    monkeyPatchWindowOpen();\n  }\n\n  handlers.push(cb);\n\n  return () => {\n    const pos = handlers ? handlers.indexOf(cb) : -1;\n    if (pos > -1) {\n      (handlers ).splice(pos, 1);\n    }\n  };\n}\n\nfunction monkeyPatchWindowOpen() {\n  fill(WINDOW, 'open', function (originalWindowOpen) {\n    return function (...args) {\n      if (handlers) {\n        try {\n          handlers.forEach(handler => handler());\n        } catch (e) {\n          // ignore errors in here\n        }\n      }\n\n      return originalWindowOpen.apply(WINDOW, args);\n    };\n  });\n}\n\n/** 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  'data-sentry-component',\n]);\n\n/**\n * Inclusion list of attributes that we want to record from the DOM element\n */\nfunction getAttributesToRecord(attributes) {\n  const obj = {};\n  for (const key in attributes) {\n    if (ATTRIBUTES_TO_RECORD.has(key)) {\n      let normalizedKey = key;\n\n      if (key === 'data-testid' || key === 'data-test-id') {\n        normalizedKey = 'testId';\n      }\n\n      obj[normalizedKey] = attributes[key];\n    }\n  }\n\n  return obj;\n}\n\nconst handleDomListener = (\n  replay,\n) => {\n  return (handlerData) => {\n    if (!replay.isEnabled()) {\n      return;\n    }\n\n    const result = handleDom(handlerData);\n\n    if (!result) {\n      return;\n    }\n\n    const isClick = handlerData.name === 'click';\n    const event = isClick ? (handlerData.event ) : undefined;\n    // Ignore clicks if ctrl/alt/meta/shift keys are held down as they alter behavior of clicks (e.g. open in new tab)\n    if (\n      isClick &&\n      replay.clickDetector &&\n      event &&\n      event.target &&\n      !event.altKey &&\n      !event.metaKey &&\n      !event.ctrlKey &&\n      !event.shiftKey\n    ) {\n      handleClick(\n        replay.clickDetector,\n        result ,\n        getClickTargetNode(handlerData.event ) ,\n      );\n    }\n\n    addBreadcrumbEvent(replay, result);\n  };\n};\n\n/** Get the base DOM breadcrumb. */\nfunction getBaseDomBreadcrumb(target, message) {\n  const nodeId = record.mirror.getId(target);\n  const node = nodeId && record.mirror.getNode(nodeId);\n  const meta = node && record.mirror.getMeta(node);\n  const element = meta && isElement(meta) ? meta : null;\n\n  return {\n    message,\n    data: element\n      ? {\n          nodeId,\n          node: {\n            id: nodeId,\n            tagName: element.tagName,\n            textContent: Array.from(element.childNodes)\n              .map((node) => node.type === NodeType.Text && node.textContent)\n              .filter(Boolean) // filter out empty values\n              .map(text => (text ).trim())\n              .join(''),\n            attributes: getAttributesToRecord(element.attributes),\n          },\n        }\n      : {},\n  };\n}\n\n/**\n * An event handler to react to DOM events.\n * Exported for tests.\n */\nfunction handleDom(handlerData) {\n  const { target, message } = getDomTarget(handlerData);\n\n  return createBreadcrumb({\n    category: `ui.${handlerData.name}`,\n    ...getBaseDomBreadcrumb(target, message),\n  });\n}\n\nfunction getDomTarget(handlerData) {\n  const isClick = handlerData.name === 'click';\n\n  let message;\n  let target = null;\n\n  // Accessing event.target can throw (see getsentry/raven-js#838, #768)\n  try {\n    target = isClick ? getClickTargetNode(handlerData.event ) : getTargetNode(handlerData.event );\n    message = htmlTreeAsString(target, { maxStringLength: 200 }) || '<unknown>';\n  } catch (e) {\n    message = '<unknown>';\n  }\n\n  return { target, message };\n}\n\nfunction isElement(node) {\n  return node.type === NodeType.Element;\n}\n\n/** Handle keyboard events & create breadcrumbs. */\nfunction handleKeyboardEvent(replay, event) {\n  if (!replay.isEnabled()) {\n    return;\n  }\n\n  // Update user activity, but do not restart recording as it can create\n  // noisy/low-value replays (e.g. user comes back from idle, hits alt-tab, new\n  // session with a single \"keydown\" breadcrumb is created)\n  replay.updateUserActivity();\n\n  const breadcrumb = getKeyboardBreadcrumb(event);\n\n  if (!breadcrumb) {\n    return;\n  }\n\n  addBreadcrumbEvent(replay, breadcrumb);\n}\n\n/** exported only for tests */\nfunction getKeyboardBreadcrumb(event) {\n  const { metaKey, shiftKey, ctrlKey, altKey, key, target } = event;\n\n  // never capture for input fields\n  if (!target || isInputElement(target ) || !key) {\n    return null;\n  }\n\n  // Note: We do not consider shift here, as that means \"uppercase\"\n  const hasModifierKey = metaKey || ctrlKey || altKey;\n  const isCharacterKey = key.length === 1; // other keys like Escape, Tab, etc have a longer length\n\n  // Do not capture breadcrumb if only a word key is pressed\n  // This could leak e.g. user input\n  if (!hasModifierKey && isCharacterKey) {\n    return null;\n  }\n\n  const message = htmlTreeAsString(target, { maxStringLength: 200 }) || '<unknown>';\n  const baseBreadcrumb = getBaseDomBreadcrumb(target , message);\n\n  return createBreadcrumb({\n    category: 'ui.keyDown',\n    message,\n    data: {\n      ...baseBreadcrumb.data,\n      metaKey,\n      shiftKey,\n      ctrlKey,\n      altKey,\n      key,\n    },\n  });\n}\n\nfunction isInputElement(target) {\n  return target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable;\n}\n\n// Map entryType -> function to normalize data for event\nconst ENTRY_TYPES\n\n = {\n  // @ts-expect-error TODO: entry type does not fit the create* functions entry type\n  resource: createResourceEntry,\n  paint: createPaintEntry,\n  // @ts-expect-error TODO: entry type does not fit the create* functions entry type\n  navigation: createNavigationEntry,\n};\n\n/**\n * 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\n/**\n * This serves as a build time flag that will be true by default, but false in non-debug builds or if users replace `__SENTRY_DEBUG__` in their generated code.\n *\n * ATTENTION: This constant must never cross package boundaries (i.e. be exported) to guarantee that it can be used for tree shaking.\n */\nconst DEBUG_BUILD = (typeof __SENTRY_DEBUG__ === 'undefined' || __SENTRY_DEBUG__);\n\nconst r = `var t=Uint8Array,n=Uint16Array,r=Int32Array,e=new t([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0,0]),i=new t([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,0,0]),a=new t([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),s=function(t,e){for(var i=new n(31),a=0;a<31;++a)i[a]=e+=1<<t[a-1];var s=new r(i[30]);for(a=1;a<30;++a)for(var o=i[a];o<i[a+1];++o)s[o]=o-i[a]<<5|a;return{b:i,r:s}},o=s(e,2),f=o.b,h=o.r;f[28]=258,h[258]=28;for(var l=s(i,0).r,u=new n(32768),c=0;c<32768;++c){var v=(43690&c)>>1|(21845&c)<<1;v=(61680&(v=(52428&v)>>2|(13107&v)<<2))>>4|(3855&v)<<4,u[c]=((65280&v)>>8|(255&v)<<8)>>1}var d=function(t,r,e){for(var i=t.length,a=0,s=new n(r);a<i;++a)t[a]&&++s[t[a]-1];var o,f=new n(r);for(a=1;a<r;++a)f[a]=f[a-1]+s[a-1]<<1;if(e){o=new n(1<<r);var h=15-r;for(a=0;a<i;++a)if(t[a])for(var l=a<<4|t[a],c=r-t[a],v=f[t[a]-1]++<<c,d=v|(1<<c)-1;v<=d;++v)o[u[v]>>h]=l}else for(o=new n(i),a=0;a<i;++a)t[a]&&(o[a]=u[f[t[a]-1]++]>>15-t[a]);return o},g=new t(288);for(c=0;c<144;++c)g[c]=8;for(c=144;c<256;++c)g[c]=9;for(c=256;c<280;++c)g[c]=7;for(c=280;c<288;++c)g[c]=8;var w=new t(32);for(c=0;c<32;++c)w[c]=5;var p=d(g,9,0),y=d(w,5,0),m=function(t){return(t+7)/8|0},b=function(n,r,e){return(null==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 (!DEBUG_BUILD) {\n    return;\n  }\n\n  logger.info(message);\n\n  if (shouldAddBreadcrumb) {\n    addLogBreadcrumb(message);\n  }\n}\n\n/**\n * Log a message, and add a breadcrumb in the next tick.\n * This is necessary when the breadcrumb may be added before the replay is initialized.\n */\nfunction logInfoNextTick(message, shouldAddBreadcrumb) {\n  if (!DEBUG_BUILD) {\n    return;\n  }\n\n  logger.info(message);\n\n  if (shouldAddBreadcrumb) {\n    // Wait a tick here to avoid race conditions for some initial logs\n    // which may be added before replay is initialized\n    setTimeout(() => {\n      addLogBreadcrumb(message);\n    }, 0);\n  }\n}\n\nfunction addLogBreadcrumb(message) {\n  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          DEBUG_BUILD && 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    this._worker.postMessage('clear').then(null, e => {\n      DEBUG_BUILD && logger.warn('[Replay] Sending \"clear\" message to worker failed', e);\n    });\n  }\n\n  /** @inheritdoc */\n   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      DEBUG_BUILD && 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 * Get a session with defaults & applied sampling.\n */\nfunction makeSession(session) {\n  const now = Date.now();\n  const id = session.id || uuid4();\n  // Note that this means we cannot set a started/lastActivity of `0`, but this should not be relevant outside of tests.\n  const started = session.started || now;\n  const lastActivity = session.lastActivity || now;\n  const segmentId = session.segmentId || 0;\n  const sampled = session.sampled;\n  const previousSessionId = session.previousSessionId;\n\n  return {\n    id,\n    started,\n    lastActivity,\n    segmentId,\n    sampled,\n    previousSessionId,\n  };\n}\n\n/**\n * Save a session to session storage.\n */\nfunction saveSession(session) {\n  if (!hasSessionStorage()) {\n    return;\n  }\n\n  try {\n    WINDOW.sessionStorage.setItem(REPLAY_SESSION_KEY, JSON.stringify(session));\n  } catch (e) {\n    // Ignore potential SecurityError exceptions\n  }\n}\n\n/**\n * Get the sampled status for a session based on sample rates & current sampled status.\n */\nfunction getSessionSampleType(sessionSampleRate, allowBuffering) {\n  return isSampled(sessionSampleRate) ? 'session' : allowBuffering ? 'buffer' : false;\n}\n\n/**\n * Create a new session, which in its current implementation is a Sentry event\n * that all replays will be saved to as attachments. Currently, we only expect\n * one of these Sentry events per \"replay session\".\n */\nfunction createSession(\n  { sessionSampleRate, allowBuffering, stickySession = false },\n  { previousSessionId } = {},\n) {\n  const sampled = getSessionSampleType(sessionSampleRate, allowBuffering);\n  const session = makeSession({\n    sampled,\n    previousSessionId,\n  });\n\n  if (stickySession) {\n    saveSession(session);\n  }\n\n  return session;\n}\n\n/**\n * Fetches a session from storage\n */\nfunction fetchSession(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  // This should never reject\n  // eslint-disable-next-line @typescript-eslint/no-floating-promises\n  _addEvent(replay, event, isCheckout);\n\n  return true;\n}\n\n/**\n * Add an event to the event buffer.\n * Resolves to `null` if no event was added, else to `void`.\n *\n * `isCheckout` is true if this is either the very first event, or an event triggered by `checkoutEveryNms`.\n */\nfunction addEvent(\n  replay,\n  event,\n  isCheckout,\n) {\n  if (!shouldAddEvent(replay, event)) {\n    return Promise.resolve(null);\n  }\n\n  return _addEvent(replay, event, isCheckout);\n}\n\nasync function _addEvent(\n  replay,\n  event,\n  isCheckout,\n) {\n  if (!replay.eventBuffer) {\n    return null;\n  }\n\n  try {\n    if (isCheckout && replay.recordingMode === 'buffer') {\n      replay.eventBuffer.clear();\n    }\n\n    if (isCheckout) {\n      replay.eventBuffer.hasCheckout = true;\n    }\n\n    const replayOptions = replay.getOptions();\n\n    const eventAfterPossibleCallback = maybeApplyCallback(event, replayOptions.beforeAddRecordingEvent);\n\n    if (!eventAfterPossibleCallback) {\n      return;\n    }\n\n    return await replay.eventBuffer.addEvent(eventAfterPossibleCallback);\n  } catch (error) {\n    const reason = error && error instanceof EventBufferSizeExceededError ? 'addEventSizeExceeded' : 'addEvent';\n\n    DEBUG_BUILD && logger.error(error);\n    await replay.stop({ reason });\n\n    const client = getClient();\n\n    if (client) {\n      client.recordDroppedEvent('internal_sdk_error', 'replay');\n    }\n  }\n}\n\n/** Exported only for tests. */\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    DEBUG_BUILD &&\n      logger.error('[Replay] An error occured in the `beforeAddRecordingEvent` callback, skipping the event...', error);\n    return null;\n  }\n\n  return event;\n}\n\n/** If the event is an error event */\nfunction isErrorEvent(event) {\n  return !event.type;\n}\n\n/** If the event is a transaction event */\nfunction isTransactionEvent(event) {\n  return event.type === 'transaction';\n}\n\n/** If the event is an replay event */\nfunction isReplayEvent(event) {\n  return event.type === 'replay_event';\n}\n\n/** If the event is a feedback event */\nfunction isFeedbackEvent(event) {\n  return event.type === 'feedback';\n}\n\n/**\n * Returns a listener to be added to `client.on('afterSendErrorEvent, listener)`.\n */\nfunction handleAfterSendEvent(replay) {\n  // 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    // This should never reject\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    replay.sendBufferedReplayOrFlush();\n  });\n}\n\nfunction isBaseTransportSend() {\n  const client = getClient();\n  if (!client) {\n    return false;\n  }\n\n  const transport = client.getTransport();\n  if (!transport) {\n    return false;\n  }\n\n  return (\n    (transport.send ).__sentry__baseTransport__ || false\n  );\n}\n\n/**\n * Returns a listener to be added to `client.on('afterSendErrorEvent, listener)`.\n */\nfunction handleBeforeSendEvent(replay) {\n  return (event) => {\n    if (!replay.isEnabled() || !isErrorEvent(event)) {\n      return;\n    }\n\n    handleHydrationError(replay, event);\n  };\n}\n\nfunction handleHydrationError(replay, event) {\n  const exceptionValue = event.exception && event.exception.values && event.exception.values[0].value;\n  if (typeof exceptionValue !== 'string') {\n    return;\n  }\n\n  if (\n    // Only matches errors in production builds of react-dom\n    // Example https://reactjs.org/docs/error-decoder.html?invariant=423\n    exceptionValue.match(/reactjs\\.org\\/docs\\/error-decoder\\.html\\?invariant=(418|419|422|423|425)/) ||\n    // Development builds of react-dom\n    // Error 1: Hydration failed because the initial UI does not match what was rendered on the server.\n    // Error 2: Text content does not match server-rendered HTML. Warning: Text content did not match.\n    exceptionValue.match(/(does not match server-rendered HTML|Hydration failed because)/i)\n  ) {\n    const breadcrumb = createBreadcrumb({\n      category: 'replay.hydrate-error',\n    });\n    addBreadcrumbEvent(replay, breadcrumb);\n  }\n}\n\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 * Add a feedback breadcrumb event to replay.\n */\nfunction addFeedbackBreadcrumb(replay, event) {\n  replay.triggerUserActivity();\n  replay.addUpdate(() => {\n    if (!event.timestamp) {\n      // Ignore events that don't have timestamps (this shouldn't happen, more of a typing issue)\n      // Return true here so that we don't flush\n      return true;\n    }\n\n    // This should never reject\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    replay.throttledAddEvent({\n      type: EventType.Custom,\n      timestamp: event.timestamp * 1000,\n      data: {\n        tag: 'breadcrumb',\n        payload: {\n          timestamp: event.timestamp,\n          type: 'default',\n          category: 'sentry.feedback',\n          data: {\n            feedbackId: event.event_id,\n          },\n        },\n      },\n    } );\n\n    return false;\n  });\n}\n\n/**\n * Determine if event should be sampled (only applies in buffer mode).\n * When an event is captured by `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 `addEventProcessor(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, and feedbacks, nothing else\n      if (!isErrorEvent(event) && !isTransactionEvent(event) && !isFeedbackEvent(event)) {\n        return event;\n      }\n\n      // Ensure we do not add replay_id if the session is expired\n      const isSessionActive = replay.checkAndHandleExpiredSession();\n      if (!isSessionActive) {\n        return event;\n      }\n\n      if (isFeedbackEvent(event)) {\n        // This should never reject\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        replay.flush();\n        event.contexts.feedback.replay_id = replay.getSessionId();\n        // Add a replay breadcrumb for this piece of feedback\n        addFeedbackBreadcrumb(replay, event);\n        return event;\n      }\n\n      // Unless `captureExceptions` is enabled, we want to ignore errors coming from rrweb\n      // As there can be a bunch of stuff going wrong in internals there, that we don't want to bubble up to users\n      if (isRrwebError(event, hint) && !replay.getOptions()._experiments.captureExceptions) {\n        DEBUG_BUILD && logger.log('[Replay] Ignoring error from rrweb internals', event);\n        return null;\n      }\n\n      // When in buffer mode, we decide to sample here.\n      // Later, in `handleAfterSendEvent`, if the replayId is set, we know that we sampled\n      // And convert the buffer session to a full session\n      const isErrorEventSampled = shouldSampleForBufferEvent(replay, event);\n\n      // Tag errors if it has been sampled in buffer mode, or if it is session mode\n      // Only tag transactions if in session mode\n      const shouldTagReplayId = isErrorEventSampled || replay.recordingMode === 'session';\n\n      if (shouldTagReplayId) {\n        event.tags = { ...event.tags, replayId: replay.getSessionId() };\n      }\n\n      // In cases where a custom client is used that does not support the new hooks (yet),\n      // we manually call this hook method here\n      if (afterSendHandler) {\n        // Pretend the error had a 200 response so we always capture it\n        afterSendHandler(event, { statusCode: 200 });\n      }\n\n      return event;\n    },\n    { id: 'Replay' },\n  );\n}\n\n/**\n * Create a \"span\" for each performance entry.\n */\nfunction createPerformanceSpans(\n  replay,\n  entries,\n) {\n  return entries.map(({ type, start, end, name, data }) => {\n    const response = replay.throttledAddEvent({\n      type: EventType.Custom,\n      timestamp: start,\n      data: {\n        tag: 'performanceSpan',\n        payload: {\n          op: type,\n          description: name,\n          startTimestamp: start,\n          endTimestamp: end,\n          data,\n        },\n      },\n    });\n\n    // If response is a string, it means its either THROTTLED or SKIPPED\n    return typeof response === 'string' ? Promise.resolve(null) : response;\n  });\n}\n\nfunction handleHistory(handlerData) {\n  const { from, to } = handlerData;\n\n  const now = Date.now() / 1000;\n\n  return {\n    type: 'navigation.push',\n    start: now,\n    end: now,\n    name: to,\n    data: {\n      previous: from,\n    },\n  };\n}\n\n/**\n * Returns a listener to be added to `addHistoryInstrumentationHandler(listener)`.\n */\nfunction handleHistorySpanListener(replay) {\n  return (handlerData) => {\n    if (!replay.isEnabled()) {\n      return;\n    }\n\n    const result = handleHistory(handlerData);\n\n    if (result === null) {\n      return;\n    }\n\n    // Need to collect visited URLs\n    replay.getContext().urls.push(result.name);\n    replay.triggerUserActivity();\n\n    replay.addUpdate(() => {\n      createPerformanceSpans(replay, [result]);\n      // Returning false to flush\n      return false;\n    });\n  };\n}\n\n/**\n * Check whether a given request URL should be filtered out. This is so we\n * don't log Sentry ingest requests.\n */\nfunction shouldFilterRequest(replay, url) {\n  // If we enabled the `traceInternals` experiment, we want to trace everything\n  if (DEBUG_BUILD && replay.getOptions()._experiments.traceInternals) {\n    return false;\n  }\n\n  return isSentryRequestUrl(url, getClient());\n}\n\n/** Add a performance entry breadcrumb */\nfunction addNetworkBreadcrumb(\n  replay,\n  result,\n) {\n  if (!replay.isEnabled()) {\n    return;\n  }\n\n  if (result === null) {\n    return;\n  }\n\n  if (shouldFilterRequest(replay, result.name)) {\n    return;\n  }\n\n  replay.addUpdate(() => {\n    createPerformanceSpans(replay, [result]);\n    // Returning true will cause `addUpdate` to not flush\n    // We do not want network requests to cause a flush. This will prevent\n    // recurring/polling requests from keeping the replay session alive.\n    return true;\n  });\n}\n\n/** 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 `addFetchInstrumentationHandler(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 `addXhrInstrumentationHandler(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  try {\n    if (typeof body === 'string') {\n      return [body];\n    }\n\n    if (body instanceof URLSearchParams) {\n      return [body.toString()];\n    }\n\n    if (body instanceof FormData) {\n      return [_serializeFormData(body)];\n    }\n\n    if (!body) {\n      return [undefined];\n    }\n  } catch (e2) {\n    DEBUG_BUILD && logger.warn('[Replay] Failed to serialize body', body);\n    return [undefined, 'BODY_PARSE_ERROR'];\n  }\n\n  DEBUG_BUILD && logger.info('[Replay] Skipping network body because of body type', body);\n\n  return [undefined, 'UNPARSEABLE_BODY_TYPE'];\n}\n\n/** Merge a warning into an existing network request/response. */\nfunction mergeWarning(\n  info,\n  warning,\n) {\n  if (!info) {\n    return {\n      headers: {},\n      size: undefined,\n      _meta: {\n        warnings: [warning],\n      },\n    };\n  }\n\n  const newMeta = { ...info._meta };\n  const existingWarnings = newMeta.warnings || [];\n  newMeta.warnings = [...existingWarnings, warning];\n\n  info._meta = newMeta;\n  return info;\n}\n\n/** Convert ReplayNetworkRequestData to a PerformanceEntry. */\nfunction makeNetworkReplayBreadcrumb(\n  type,\n  data,\n) {\n  if (!data) {\n    return null;\n  }\n\n  const { startTimestamp, endTimestamp, url, method, statusCode, request, response } = data;\n\n  const result = {\n    type,\n    start: startTimestamp / 1000,\n    end: endTimestamp / 1000,\n    name: url,\n    data: dropUndefinedKeys({\n      method,\n      statusCode,\n      request,\n      response,\n    }),\n  };\n\n  return result;\n}\n\n/** Build the request or response part of a replay network breadcrumb that was skipped. */\nfunction buildSkippedNetworkRequestOrResponse(bodySize) {\n  return {\n    headers: {},\n    size: bodySize,\n    _meta: {\n      warnings: ['URL_SKIPPED'],\n    },\n  };\n}\n\n/** Build the request or response part of a replay network breadcrumb. */\nfunction buildNetworkRequestOrResponse(\n  headers,\n  bodySize,\n  body,\n) {\n  if (!bodySize && Object.keys(headers).length === 0) {\n    return undefined;\n  }\n\n  if (!bodySize) {\n    return {\n      headers,\n    };\n  }\n\n  if (!body) {\n    return {\n      headers,\n      size: bodySize,\n    };\n  }\n\n  const info = {\n    headers,\n    size: bodySize,\n  };\n\n  const { body: normalizedBody, warnings } = normalizeNetworkBody(body);\n  info.body = normalizedBody;\n  if (warnings && warnings.length > 0) {\n    info._meta = {\n      warnings,\n    };\n  }\n\n  return info;\n}\n\n/** Filter a set of headers */\nfunction getAllowedHeaders(headers, allowedHeaders) {\n  return Object.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  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    DEBUG_BUILD && logger.error('[Replay] Failed to capture fetch breadcrumb', error);\n  }\n}\n\n/**\n * Enrich a breadcrumb with additional data.\n * This has to be sync & mutate the given breadcrumb,\n * as the breadcrumb is afterwards consumed by other handlers.\n */\nfunction enrichFetchBreadcrumb(\n  breadcrumb,\n  hint,\n  options,\n) {\n  const { input, response } = hint;\n\n  const body = input ? _getFetchRequestArgBody(input) : undefined;\n  const reqSize = getBodySize(body, options.textEncoder);\n\n  const resSize = response ? parseContentLengthHeader(response.headers.get('content-length')) : undefined;\n\n  if (reqSize !== undefined) {\n    breadcrumb.data.request_body_size = reqSize;\n  }\n  if (resSize !== undefined) {\n    breadcrumb.data.response_body_size = resSize;\n  }\n}\n\nasync function _prepareFetchData(\n  breadcrumb,\n  hint,\n  options\n\n,\n) {\n  const now = Date.now();\n  const { startTimestamp = now, endTimestamp = now } = hint;\n\n  const {\n    url,\n    method,\n    status_code: statusCode = 0,\n    request_body_size: requestBodySize,\n    response_body_size: responseBodySize,\n  } = breadcrumb.data;\n\n  const captureDetails =\n    urlMatches(url, options.networkDetailAllowUrls) && !urlMatches(url, options.networkDetailDenyUrls);\n\n  const request = captureDetails\n    ? _getRequestInfo(options, hint.input, requestBodySize)\n    : buildSkippedNetworkRequestOrResponse(requestBodySize);\n  const response = await _getResponseInfo(captureDetails, options, hint.response, responseBodySize);\n\n  return {\n    startTimestamp,\n    endTimestamp,\n    url,\n    method,\n    statusCode,\n    request,\n    response,\n  };\n}\n\nfunction _getRequestInfo(\n  { networkCaptureBodies, networkRequestHeaders },\n  input,\n  requestBodySize,\n) {\n  const headers = input ? getRequestHeaders(input, networkRequestHeaders) : {};\n\n  if (!networkCaptureBodies) {\n    return buildNetworkRequestOrResponse(headers, requestBodySize, undefined);\n  }\n\n  // We only want to transmit string or string-like bodies\n  const requestBody = _getFetchRequestArgBody(input);\n  const [bodyStr, warning] = getBodyString(requestBody);\n  const data = buildNetworkRequestOrResponse(headers, requestBodySize, bodyStr);\n\n  if (warning) {\n    return mergeWarning(data, warning);\n  }\n\n  return data;\n}\n\n/** Exported only for tests. */\nasync function _getResponseInfo(\n  captureDetails,\n  {\n    networkCaptureBodies,\n    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 = response ? getAllHeaders(response.headers, networkResponseHeaders) : {};\n\n  if (!response || (!networkCaptureBodies && responseBodySize !== undefined)) {\n    return buildNetworkRequestOrResponse(headers, responseBodySize, undefined);\n  }\n\n  const [bodyText, warning] = await _parseFetchResponseBody(response);\n  const result = getResponseData(bodyText, {\n    networkCaptureBodies,\n    textEncoder,\n    responseBodySize,\n    captureDetails,\n    headers,\n  });\n\n  if (warning) {\n    return mergeWarning(result, warning);\n  }\n\n  return result;\n}\n\nfunction getResponseData(\n  bodyText,\n  {\n    networkCaptureBodies,\n    textEncoder,\n    responseBodySize,\n    captureDetails,\n    headers,\n  }\n\n,\n) {\n  try {\n    const size =\n      bodyText && bodyText.length && responseBodySize === undefined\n        ? getBodySize(bodyText, textEncoder)\n        : responseBodySize;\n\n    if (!captureDetails) {\n      return buildSkippedNetworkRequestOrResponse(size);\n    }\n\n    if (networkCaptureBodies) {\n      return buildNetworkRequestOrResponse(headers, size, bodyText);\n    }\n\n    return buildNetworkRequestOrResponse(headers, size, undefined);\n  } catch (error) {\n    DEBUG_BUILD && logger.warn('[Replay] Failed to serialize response body', error);\n    // fallback\n    return buildNetworkRequestOrResponse(headers, responseBodySize, undefined);\n  }\n}\n\nasync function _parseFetchResponseBody(response) {\n  const res = _tryCloneResponse(response);\n\n  if (!res) {\n    return [undefined, 'BODY_PARSE_ERROR'];\n  }\n\n  try {\n    const text = await _tryGetResponseText(res);\n    return [text];\n  } catch (error) {\n    DEBUG_BUILD && logger.warn('[Replay] Failed to get text body from response', error);\n    return [undefined, 'BODY_PARSE_ERROR'];\n  }\n}\n\nfunction _getFetchRequestArgBody(fetchArgs = []) {\n  // We only support getting the body from the fetch options\n  if (fetchArgs.length !== 2 || typeof fetchArgs[1] !== 'object') {\n    return undefined;\n  }\n\n  return (fetchArgs[1] ).body;\n}\n\nfunction getAllHeaders(headers, allowedHeaders) {\n  const allHeaders = {};\n\n  allowedHeaders.forEach(header => {\n    if (headers.get(header)) {\n      allHeaders[header] = headers.get(header) ;\n    }\n  });\n\n  return allHeaders;\n}\n\nfunction getRequestHeaders(fetchArgs, allowedHeaders) {\n  if (fetchArgs.length === 1 && typeof fetchArgs[0] !== 'string') {\n    return getHeadersFromOptions(fetchArgs[0] , allowedHeaders);\n  }\n\n  if (fetchArgs.length === 2) {\n    return getHeadersFromOptions(fetchArgs[1] , allowedHeaders);\n  }\n\n  return {};\n}\n\nfunction getHeadersFromOptions(\n  input,\n  allowedHeaders,\n) {\n  if (!input) {\n    return {};\n  }\n\n  const headers = input.headers;\n\n  if (!headers) {\n    return {};\n  }\n\n  if (headers instanceof Headers) {\n    return getAllHeaders(headers, allowedHeaders);\n  }\n\n  // We do not support this, as it is not really documented (anymore?)\n  if (Array.isArray(headers)) {\n    return {};\n  }\n\n  return getAllowedHeaders(headers, allowedHeaders);\n}\n\nfunction _tryCloneResponse(response) {\n  try {\n    // We have to clone this, as the body can only be read once\n    return response.clone();\n  } catch (error) {\n    // this can throw if the response was already consumed before\n    DEBUG_BUILD && logger.warn('[Replay] Failed to clone response body', error);\n  }\n}\n\n/**\n * Get the response body of a fetch request, or timeout after 500ms.\n * Fetch can return a streaming body, that may not resolve (or not for a long time).\n * If that happens, we rather abort after a short time than keep waiting for this.\n */\nfunction _tryGetResponseText(response) {\n  return new Promise((resolve, reject) => {\n    const timeout = setTimeout(() => reject(new Error('Timeout while trying to read response body')), 500);\n\n    _getResponseText(response)\n      .then(\n        txt => resolve(txt),\n        reason => reject(reason),\n      )\n      .finally(() => clearTimeout(timeout));\n  });\n}\n\nasync function _getResponseText(response) {\n  // Force this to be a promise, just to be safe\n  // eslint-disable-next-line no-return-await\n  return await response.text();\n}\n\n/**\n * Capture an XHR breadcrumb to a replay.\n * This adds additional data (where 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    DEBUG_BUILD && logger.error('[Replay] Failed to capture xhr breadcrumb', error);\n  }\n}\n\n/**\n * Enrich a breadcrumb with additional data.\n * This has to be sync & mutate the given breadcrumb,\n * as the breadcrumb is afterwards consumed by other handlers.\n */\nfunction enrichXhrBreadcrumb(\n  breadcrumb,\n  hint,\n  options,\n) {\n  const { xhr, input } = hint;\n\n  if (!xhr) {\n    return;\n  }\n\n  const reqSize = getBodySize(input, options.textEncoder);\n  const resSize = xhr.getResponseHeader('content-length')\n    ? parseContentLengthHeader(xhr.getResponseHeader('content-length'))\n    : _getBodySize(xhr.response, xhr.responseType, options.textEncoder);\n\n  if (reqSize !== undefined) {\n    breadcrumb.data.request_body_size = reqSize;\n  }\n  if (resSize !== undefined) {\n    breadcrumb.data.response_body_size = resSize;\n  }\n}\n\nfunction _prepareXhrData(\n  breadcrumb,\n  hint,\n  options,\n) {\n  const now = Date.now();\n  const { startTimestamp = now, endTimestamp = now, input, xhr } = hint;\n\n  const {\n    url,\n    method,\n    status_code: statusCode = 0,\n    request_body_size: requestBodySize,\n    response_body_size: responseBodySize,\n  } = breadcrumb.data;\n\n  if (!url) {\n    return null;\n  }\n\n  if (!xhr || !urlMatches(url, options.networkDetailAllowUrls) || urlMatches(url, options.networkDetailDenyUrls)) {\n    const request = buildSkippedNetworkRequestOrResponse(requestBodySize);\n    const response = buildSkippedNetworkRequestOrResponse(responseBodySize);\n    return {\n      startTimestamp,\n      endTimestamp,\n      url,\n      method,\n      statusCode,\n      request,\n      response,\n    };\n  }\n\n  const xhrInfo = xhr[SENTRY_XHR_DATA_KEY];\n  const networkRequestHeaders = xhrInfo\n    ? getAllowedHeaders(xhrInfo.request_headers, options.networkRequestHeaders)\n    : {};\n  const networkResponseHeaders = getAllowedHeaders(getResponseHeaders(xhr), options.networkResponseHeaders);\n\n  const [requestBody, requestWarning] = options.networkCaptureBodies ? getBodyString(input) : [undefined];\n  const [responseBody, responseWarning] = options.networkCaptureBodies ? _getXhrResponseBody(xhr) : [undefined];\n\n  const request = buildNetworkRequestOrResponse(networkRequestHeaders, requestBodySize, requestBody);\n  const response = buildNetworkRequestOrResponse(networkResponseHeaders, responseBodySize, responseBody);\n\n  return {\n    startTimestamp,\n    endTimestamp,\n    url,\n    method,\n    statusCode,\n    request: requestWarning ? mergeWarning(request, requestWarning) : request,\n    response: responseWarning ? mergeWarning(response, responseWarning) : response,\n  };\n}\n\nfunction getResponseHeaders(xhr) {\n  const headers = xhr.getAllResponseHeaders();\n\n  if (!headers) {\n    return {};\n  }\n\n  return headers.split('\\r\\n').reduce((acc, line) => {\n    const [key, value] = line.split(': ');\n    acc[key.toLowerCase()] = value;\n    return acc;\n  }, {});\n}\n\nfunction _getXhrResponseBody(xhr) {\n  // We collect errors that happen, but only log them if we can't get any response body\n  const errors = [];\n\n  try {\n    return [xhr.responseText];\n  } catch (e) {\n    errors.push(e);\n  }\n\n  // Try to manually parse the response body, if responseText fails\n  try {\n    return _parseXhrResponse(xhr.response, xhr.responseType);\n  } catch (e) {\n    errors.push(e);\n  }\n\n  DEBUG_BUILD && logger.warn('[Replay] Failed to get xhr response body', ...errors);\n\n  return [undefined];\n}\n\n/**\n * Get the string representation of the XHR response.\n * Based on MDN, these are the possible types of the response:\n * string\n * ArrayBuffer\n * Blob\n * Document\n * POJO\n *\n * Exported only for tests.\n */\nfunction _parseXhrResponse(\n  body,\n  responseType,\n) {\n  try {\n    if (typeof body === 'string') {\n      return [body];\n    }\n\n    if (body instanceof Document) {\n      return [body.body.outerHTML];\n    }\n\n    if (responseType === 'json' && body && typeof body === 'object') {\n      return [JSON.stringify(body)];\n    }\n\n    if (!body) {\n      return [undefined];\n    }\n  } catch (e2) {\n    DEBUG_BUILD && logger.warn('[Replay] Failed to serialize body', body);\n    return [undefined, 'BODY_PARSE_ERROR'];\n  }\n\n  DEBUG_BUILD && logger.info('[Replay] Skipping network body because of body type', body);\n\n  return [undefined, 'UNPARSEABLE_BODY_TYPE'];\n}\n\nfunction _getBodySize(\n  body,\n  responseType,\n  textEncoder,\n) {\n  try {\n    const bodyStr = responseType === 'json' && body && typeof body === 'object' ? JSON.stringify(body) : body;\n    return getBodySize(bodyStr, textEncoder);\n  } catch (e3) {\n    return undefined;\n  }\n}\n\n/**\n * This method does two things:\n * - It enriches the regular XHR/fetch breadcrumbs with request/response size data\n * - It captures the XHR/fetch breadcrumbs to the replay\n *   (enriching it with further data that is _not_ added to the regular breadcrumbs)\n */\nfunction handleNetworkBreadcrumbs(replay) {\n  const client = getClient();\n\n  try {\n    const 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      addFetchInstrumentationHandler(handleFetchSpanListener(replay));\n      addXhrInstrumentationHandler(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      // This call should not reject\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      captureXhrBreadcrumbToReplay(breadcrumb, hint, options);\n    }\n\n    if (_isFetchBreadcrumb(breadcrumb) && _isFetchHint(hint)) {\n      // This has to be sync, as we need to ensure the breadcrumb is enriched in the same tick\n      // Because the hook runs synchronously, and the breadcrumb is afterwards passed on\n      // So any async mutations to it will not be reflected in the final breadcrumb\n      enrichFetchBreadcrumb(breadcrumb, hint, options);\n\n      // This call should not reject\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      captureFetchBreadcrumbToReplay(breadcrumb, hint, options);\n    }\n  } catch (e) {\n    DEBUG_BUILD && logger.warn('Error when enriching network breadcrumb');\n  }\n}\n\nfunction _isXhrBreadcrumb(breadcrumb) {\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 = getCurrentScope();\n  const client = getClient();\n\n  scope.addScopeListener(handleScopeListener(replay));\n  addClickKeypressInstrumentationHandler(handleDomListener(replay));\n  addHistoryInstrumentationHandler(handleHistorySpanListener(replay));\n  handleNetworkBreadcrumbs(replay);\n\n  // Tag all (non replay) events that get sent to Sentry with the current\n  // replay ID so that we can reference them later in the UI\n  const eventProcessor = handleGlobalEventListener(replay, !hasHooks(client));\n  if (client && client.addEventProcessor) {\n    client.addEventProcessor(eventProcessor);\n  } else {\n    addEventProcessor(eventProcessor);\n  }\n\n  // If a custom client has no hooks yet, we continue to use the \"old\" implementation\n  if (hasHooks(client)) {\n    client.on('beforeSendEvent', handleBeforeSendEvent(replay));\n    client.on('afterSendEvent', handleAfterSendEvent(replay));\n    client.on('createDsc', (dsc) => {\n      const replayId = replay.getSessionId();\n      // We do not want to set the DSC when in buffer mode, as that means the replay has not been sent (yet)\n      if (replayId && replay.isEnabled() && replay.recordingMode === 'session') {\n        // Ensure to check that the session is still active - it could have expired in the meanwhile\n        const isSessionActive = replay.checkAndHandleExpiredSession();\n        if (isSessionActive) {\n          dsc.replay_id = replayId;\n        }\n      }\n    });\n\n    client.on('startTransaction', transaction => {\n      replay.lastTransaction = transaction;\n    });\n\n    // We may be missing the initial startTransaction due to timing issues,\n    // so we capture it on finish again.\n    client.on('finishTransaction', transaction => {\n      replay.lastTransaction = transaction;\n    });\n\n    // We want to flush replay\n    client.on('beforeSendFeedback', (feedbackEvent, options) => {\n      const replayId = replay.getSessionId();\n      if (options && options.includeReplay && replay.isEnabled() && replayId) {\n        // This should never reject\n        if (feedbackEvent.contexts && feedbackEvent.contexts.feedback) {\n          feedbackEvent.contexts.feedback.replay_id = replayId;\n        }\n      }\n    });\n  }\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nfunction hasHooks(client) {\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      DEBUG_BUILD && logger.warn('[Replay] Received replay event after session expired.');\n\n      return;\n    }\n\n    // `_isCheckout` is only set when the checkout is due to `checkoutEveryNms`\n    // We also want to treat the first event as a checkout, so we handle this specifically here\n    const isCheckout = _isCheckout || !hadFirstEvent;\n    hadFirstEvent = true;\n\n    if (replay.clickDetector) {\n      updateClickDetectorForRecordingEvent(replay.clickDetector, event);\n    }\n\n    // The handler returns `true` if we do not want to trigger debounced flush, `false` if we want to debounce flush.\n    replay.addUpdate(() => {\n      // The session is always started immediately on pageload/init, but for\n      // error-only replays, it should reflect the most recent checkout\n      // when an error occurs. Clear any state that happens before this current\n      // checkout. This needs to happen before `addEvent()` which updates state\n      // dependent on this reset.\n      if (replay.recordingMode === 'buffer' && isCheckout) {\n        replay.setInitialState();\n      }\n\n      // If the event is not added (e.g. due to being paused, disabled, or out of the max replay duration),\n      // Skip all further steps\n      if (!addEventSync(replay, event, isCheckout)) {\n        // Return true to skip scheduling a debounced flush\n        return true;\n      }\n\n      // Different behavior for full snapshots (type=2), ignore other event types\n      // See https://github.com/rrweb-io/rrweb/blob/d8f9290ca496712aa1e7d472549480c4e7876594/packages/rrweb/src/types.ts#L16\n      if (!isCheckout) {\n        return false;\n      }\n\n      // Additionally, create a meta event that will capture certain SDK settings.\n      // In order to handle buffer mode, this needs to either be done when we\n      // receive checkout events or at flush time.\n      //\n      // `isCheckout` is always true, but want to be explicit that it should\n      // only be added for checkouts\n      addSettingsEvent(replay, isCheckout);\n\n      // If there is a previousSessionId after a full snapshot occurs, then\n      // the replay session was started due to session expiration. The new session\n      // is started before triggering a new checkout and contains the id\n      // of the previous session. Do not immediately flush in this case\n      // to avoid capturing only the checkout and instead the replay will\n      // be captured if they perform any follow-up actions.\n      if (replay.session && replay.session.previousSessionId) {\n        return true;\n      }\n\n      // When in buffer mode, make sure we adjust the session started date to the current earliest event of the buffer\n      // this should usually be the timestamp of the checkout event, but to be safe...\n      if (replay.recordingMode === 'buffer' && replay.session && replay.eventBuffer) {\n        const earliestEvent = replay.eventBuffer.getEarliestTimestamp();\n        if (earliestEvent) {\n          logInfo(\n            `[Replay] Updating session start time to earliest event in buffer to ${new Date(earliestEvent)}`,\n            replay.getOptions()._experiments.traceInternals,\n          );\n\n          replay.session.started = earliestEvent;\n\n          if (replay.getOptions().stickySession) {\n            saveSession(replay.session);\n          }\n        }\n      }\n\n      if (replay.recordingMode === 'session') {\n        // If the full snapshot is due to an initial load, we will not have\n        // a previous session ID. In this case, we want to buffer events\n        // for a set amount of time before flushing. This can help avoid\n        // capturing replays of users that immediately close the window.\n\n        // This should never reject\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        void replay.flush();\n      }\n\n      return true;\n    });\n  };\n}\n\n/**\n * Exported for tests\n */\nfunction createOptionsEvent(replay) {\n  const options = replay.getOptions();\n  return {\n    type: EventType.Custom,\n    timestamp: Date.now(),\n    data: {\n      tag: 'options',\n      payload: {\n        shouldRecordCanvas: replay.isRecordingCanvas(),\n        sessionSampleRate: options.sessionSampleRate,\n        errorSampleRate: options.errorSampleRate,\n        useCompressionOption: options.useCompression,\n        blockAllMedia: options.blockAllMedia,\n        maskAllText: options.maskAllText,\n        maskAllInputs: options.maskAllInputs,\n        useCompression: replay.eventBuffer ? replay.eventBuffer.type === 'worker' : false,\n        networkDetailHasUrls: options.networkDetailAllowUrls.length > 0,\n        networkCaptureBodies: options.networkCaptureBodies,\n        networkRequestHasHeaders: options.networkRequestHeaders.length > 0,\n        networkResponseHasHeaders: options.networkResponseHeaders.length > 0,\n      },\n    },\n  };\n}\n\n/**\n * Add a \"meta\" event that contains a simplified view on current configuration\n * options. This should only be included on the first segment of a recording.\n */\nfunction addSettingsEvent(replay, isCheckout) {\n  // Only need to add this event when sending the first segment\n  if (!isCheckout || !replay.session || replay.session.segmentId !== 0) {\n    return;\n  }\n\n  addEventSync(replay, createOptionsEvent(replay), false);\n}\n\n/**\n * Create a replay envelope ready to be sent.\n * This includes both the replay event, as well as the recording data.\n */\nfunction createReplayEnvelope(\n  replayEvent,\n  recordingData,\n  dsn,\n  tunnel,\n) {\n  return createEnvelope(\n    createEventEnvelopeHeaders(replayEvent, getSdkMetadataForEnvelopeHeader(replayEvent), tunnel, dsn),\n    [\n      [{ type: 'replay_event' }, replayEvent],\n      [\n        {\n          type: 'replay_recording',\n          // If string then we need to encode to UTF8, otherwise will have\n          // wrong size. TextEncoder has similar browser support to\n          // MutationObserver, although it does not accept IE11.\n          length:\n            typeof recordingData === 'string' ? new TextEncoder().encode(recordingData).length : recordingData.length,\n        },\n        recordingData,\n      ],\n    ],\n  );\n}\n\n/**\n * Prepare the recording data ready to be sent.\n */\nfunction prepareRecordingData({\n  recordingData,\n  headers,\n}\n\n) {\n  let payloadWithSequence;\n\n  // XXX: newline is needed to separate sequence id from events\n  const replayHeaders = `${JSON.stringify(headers)}\n`;\n\n  if (typeof recordingData === 'string') {\n    payloadWithSequence = `${replayHeaders}${recordingData}`;\n  } else {\n    const enc = new TextEncoder();\n    // XXX: newline is needed to separate sequence id from events\n    const sequence = enc.encode(replayHeaders);\n    // Merge the two Uint8Arrays\n    payloadWithSequence = new Uint8Array(sequence.length + recordingData.length);\n    payloadWithSequence.set(sequence);\n    payloadWithSequence.set(recordingData, sequence.length);\n  }\n\n  return payloadWithSequence;\n}\n\n/**\n * Prepare a replay event & enrich it with the SDK metadata.\n */\nasync function prepareReplayEvent({\n  client,\n  scope,\n  replayId: event_id,\n  event,\n}\n\n) {\n  const integrations =\n    typeof client._integrations === 'object' && client._integrations !== null && !Array.isArray(client._integrations)\n      ? Object.keys(client._integrations)\n      : undefined;\n\n  const eventHint = { event_id, integrations };\n\n  if (client.emit) {\n    client.emit('preprocessEvent', event, eventHint);\n  }\n\n  const preparedEvent = (await prepareEvent(\n    client.getOptions(),\n    event,\n    eventHint,\n    scope,\n    client,\n    getIsolationScope(),\n  )) ;\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 client = getClient();\n  const scope = getCurrentScope();\n  const transport = client && client.getTransport();\n  const dsn = client && client.getDsn();\n\n  if (!client || !transport || !dsn || !session.sampled) {\n    return;\n  }\n\n  const baseEvent = {\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 (DEBUG_BUILD && options._experiments && options._experiments.captureExceptions) {\n      captureException(err);\n    }\n\n    // If an error happened here, it's likely that uploading the attachment\n    // failed, we'll can retry with the same events payload\n    if (retryConfig.count >= RETRY_MAX_COUNT) {\n      const error = new Error(`${UNABLE_TO_SEND_REPLAY} - max retries exceeded`);\n\n      try {\n        // In case browsers don't allow this property to be writable\n        // @ts-expect-error This needs lib es2022 and newer\n        error.cause = err;\n      } catch (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  /**\n   * Internal use for canvas recording options\n   */\n\n   constructor({\n    options,\n    recordingOptions,\n  }\n\n) {ReplayContainer.prototype.__init.call(this);ReplayContainer.prototype.__init2.call(this);ReplayContainer.prototype.__init3.call(this);ReplayContainer.prototype.__init4.call(this);ReplayContainer.prototype.__init5.call(this);ReplayContainer.prototype.__init6.call(this);\n    this.eventBuffer = null;\n    this.performanceEntries = [];\n    this.replayPerformanceEntries = [];\n    this.recordingMode = 'session';\n    this.timeouts = {\n      sessionIdlePause: SESSION_IDLE_PAUSE_DURATION,\n      sessionIdleExpire: SESSION_IDLE_EXPIRE_DURATION,\n    } ;\n    this._lastActivity = Date.now();\n    this._isEnabled = false;\n    this._isPaused = false;\n    this._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  /**\n   * Determine if canvas recording is enabled\n   */\n   isRecordingCanvas() {\n    return Boolean(this._canvas);\n  }\n\n  /** Get the replay integration options. */\n   getOptions() {\n    return this._options;\n  }\n\n  /**\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    // Required as user activity is initially set in\n    // constructor, so if `start()` is called after\n    // session idle expiration, a replay will not be\n    // created due to an idle timeout.\n    this._updateUserActivity();\n\n    const session = loadOrCreateSession(\n      {\n        maxReplayDuration: this._options.maxReplayDuration,\n        sessionIdleExpire: this.timeouts.sessionIdleExpire,\n        traceInternals: this._options._experiments.traceInternals,\n      },\n      {\n        stickySession: this._options.stickySession,\n        // This is intentional: create a new session-based replay when calling `start()`\n        sessionSampleRate: 1,\n        allowBuffering: false,\n      },\n    );\n\n    this.session = session;\n\n    this._initializeRecording();\n  }\n\n  /**\n   * Start replay buffering. Buffers until `flush()` is called or, if\n   * `replaysOnErrorSampleRate` > 0, an error occurs.\n   */\n   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      const canvasOptions = this._canvas;\n\n      this._stopRecording = record({\n        ...this._recordingOptions,\n        // When running in error sampling mode, we need to overwrite `checkoutEveryNms`\n        // Without this, it would record forever, until an error happens, which we don't want\n        // instead, we'll always keep the last 60 seconds of replay before an error happened\n        ...(this.recordingMode === 'buffer' && { checkoutEveryNms: BUFFER_CHECKOUT_TIME }),\n        emit: getHandleRecordingEmit(this),\n        onMutation: this._onMutationHandler,\n        ...(canvasOptions\n          ? {\n              recordCanvas: canvasOptions.recordCanvas,\n              getCanvasManager: canvasOptions.getCanvasManager,\n              sampling: canvasOptions.sampling,\n              dataURLOptions: canvasOptions.dataURLOptions,\n            }\n          : {}),\n      });\n    } catch (err) {\n      this._handleException(err);\n    }\n  }\n\n  /**\n   * Stops the recording, if it was running.\n   *\n   * Returns true if it was previously stopped, or is now stopped,\n   * otherwise false.\n   */\n   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    // eslint-disable-next-line deprecation/deprecation\n    const lastTransaction = this.lastTransaction || getCurrentScope().getTransaction();\n\n    const attributes = (lastTransaction && spanToJSON(lastTransaction).data) || {};\n    const source = attributes[SEMANTIC_ATTRIBUTE_SENTRY_SOURCE];\n    if (!lastTransaction || !source || !['route', 'custom'].includes(source)) {\n      return undefined;\n    }\n\n    return spanToJSON(lastTransaction).description;\n  }\n\n  /**\n   * Initialize and start all listeners to varying events (DOM,\n   * Performance Observer, Recording, Sentry SDK, etc)\n   */\n   _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    DEBUG_BUILD && logger.error('[Replay]', error);\n\n    if (DEBUG_BUILD && this._options._experiments && this._options._experiments.captureExceptions) {\n      captureException(error);\n    }\n  }\n\n  /**\n   * Loads (or refreshes) the current session.\n   */\n   _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      // This should never reject\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      this._refreshSession(currentSession);\n      return false;\n    }\n\n    return true;\n  }\n\n  /**\n   * Refresh a session with a new one.\n   * This stops the current session (without forcing a flush, as that would never work since we are expired),\n   * and then does a new sampling based on the refreshed session.\n   */\n   async _refreshSession(session) {\n    if (!this._isEnabled) {\n      return;\n    }\n    await this.stop({ reason: 'refresh session' });\n    this.initializeSampling(session.id);\n  }\n\n  /**\n   * Adds listeners to record events for the replay\n   */\n   _addListeners() {\n    try {\n      WINDOW.document.addEventListener('visibilitychange', this._handleVisibilityChange);\n      WINDOW.addEventListener('blur', this._handleWindowBlur);\n      WINDOW.addEventListener('focus', this._handleWindowFocus);\n      WINDOW.addEventListener('keydown', this._handleKeyboardEvent);\n\n      if (this.clickDetector) {\n        this.clickDetector.addListeners();\n      }\n\n      // There is no way to remove these listeners, so ensure they are only added once\n      if (!this._hasInitializedCoreListeners) {\n        addGlobalListeners(this);\n\n        this._hasInitializedCoreListeners = true;\n      }\n    } catch (err) {\n      this._handleException(err);\n    }\n\n    this._performanceCleanupCallback = setupPerformanceObserver(this);\n  }\n\n  /**\n   * Cleans up listeners that were created in `_addListeners`\n   */\n   _removeListeners() {\n    try {\n      WINDOW.document.removeEventListener('visibilitychange', this._handleVisibilityChange);\n\n      WINDOW.removeEventListener('blur', this._handleWindowBlur);\n      WINDOW.removeEventListener('focus', this._handleWindowFocus);\n      WINDOW.removeEventListener('keydown', this._handleKeyboardEvent);\n\n      if (this.clickDetector) {\n        this.clickDetector.removeListeners();\n      }\n\n      if (this._performanceCleanupCallback) {\n        this._performanceCleanupCallback();\n      }\n    } catch (err) {\n      this._handleException(err);\n    }\n  }\n\n  /**\n   * Handle when visibility of the page content changes. Opening a new tab will\n   * cause the state to change to hidden because of content of current page will\n   * be hidden. Likewise, moving a different window to cover the contents of the\n   * page will also trigger a change to a hidden state.\n   */\n   __init() {this._handleVisibilityChange = () => {\n    if (WINDOW.document.visibilityState === 'visible') {\n      this._doChangeToForegroundTasks();\n    } else {\n      this._doChangeToBackgroundTasks();\n    }\n  };}\n\n  /**\n   * Handle when page is blurred\n   */\n   __init2() {this._handleWindowBlur = () => {\n    const breadcrumb = createBreadcrumb({\n      category: 'ui.blur',\n    });\n\n    // Do not count blur as a user action -- it's part of the process of them\n    // leaving the page\n    this._doChangeToBackgroundTasks(breadcrumb);\n  };}\n\n  /**\n   * Handle when page is focused\n   */\n   __init3() {this._handleWindowFocus = () => {\n    const breadcrumb = createBreadcrumb({\n      category: 'ui.focus',\n    });\n\n    // Do not count focus as a user action -- instead wait until they focus and\n    // interactive with page\n    this._doChangeToForegroundTasks(breadcrumb);\n  };}\n\n  /** Ensure page remains active when a key is pressed. */\n   __init4() {this._handleKeyboardEvent = (event) => {\n    handleKeyboardEvent(this, event);\n  };}\n\n  /**\n   * Tasks to run when we consider a page to be hidden (via blurring and/or visibility)\n   */\n   _doChangeToBackgroundTasks(breadcrumb) {\n    if (!this.session) {\n      return;\n    }\n\n    const expired = isSessionExpired(this.session, {\n      maxReplayDuration: this._options.maxReplayDuration,\n      sessionIdleExpire: this.timeouts.sessionIdleExpire,\n    });\n\n    if (expired) {\n      return;\n    }\n\n    if (breadcrumb) {\n      this._createCustomBreadcrumb(breadcrumb);\n    }\n\n    // Send replay when the page/tab becomes hidden. There is no reason to send\n    // replay if it becomes visible, since no actions we care about were done\n    // while it was hidden\n    // This should never reject\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    void this.conditionalFlush();\n  }\n\n  /**\n   * Tasks to run when we consider a page to be visible (via focus and/or visibility)\n   */\n   _doChangeToForegroundTasks(breadcrumb) {\n    if (!this.session) {\n      return;\n    }\n\n    const isSessionActive = this.checkAndHandleExpiredSession();\n\n    if (!isSessionActive) {\n      // If the user has come back to the page within SESSION_IDLE_PAUSE_DURATION\n      // ms, we will re-use the existing session, otherwise create a new\n      // session\n      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      // This should never reject\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      this.throttledAddEvent({\n        type: EventType.Custom,\n        timestamp: breadcrumb.timestamp || 0,\n        data: {\n          tag: 'breadcrumb',\n          payload: breadcrumb,\n        },\n      });\n    });\n  }\n\n  /**\n   * Observed performance events are added to `this.performanceEntries`. These\n   * are included in the replay event before it is finished and sent to Sentry.\n   */\n   _addPerformanceEntries() {\n    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      DEBUG_BUILD && logger.error('[Replay] No session or eventBuffer found to flush.');\n      return;\n    }\n\n    await this._addPerformanceEntries();\n\n    // Check eventBuffer again, as it could have been stopped in the meanwhile\n    if (!this.eventBuffer || !this.eventBuffer.hasEvents) {\n      return;\n    }\n\n    // Only attach memory event if eventBuffer is not empty\n    await addMemoryEntry(this);\n\n    // Check eventBuffer again, as it could have been stopped in the meanwhile\n    if (!this.eventBuffer) {\n      return;\n    }\n\n    // if this changed in the meanwhile, e.g. because the session was refreshed or similar, we abort here\n    if (replayId !== this.getSessionId()) {\n      return;\n    }\n\n    try {\n      // This uses the data from the eventBuffer, so we need to call this before `finish()\n      this._updateInitialTimestampFromEventBuffer();\n\n      const timestamp = Date.now();\n\n      // Check total duration again, to avoid sending outdated stuff\n      // We leave 30s wiggle room to accomodate late flushing etc.\n      // This _could_ happen when the browser is suspended during flushing, in which case we just want to stop\n      if (timestamp - this._context.initialTimestamp > this._options.maxReplayDuration + 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      // This should never reject\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      this.stop({ reason: 'sendReplay' });\n\n      const client = getClient();\n\n      if (client) {\n        client.recordDroppedEvent('send_error', 'replay');\n      }\n    }\n  }\n\n  /**\n   * Flush recording data to Sentry. Creates a lock so that only a single flush\n   * can be active at a time. Do not call this directly.\n   */\n   __init5() {this._flush = async ({\n    force = false,\n  }\n\n = {}) => {\n    if (!this._isEnabled && !force) {\n      // This can happen if e.g. the replay was stopped because of exceeding the retry limit\n      return;\n    }\n\n    if (!this.checkAndHandleExpiredSession()) {\n      DEBUG_BUILD && logger.error('[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      DEBUG_BUILD && 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      // This should never reject\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      this.stop({ reason: 'mutationLimit', forceFlush: this.recordingMode === 'session' });\n      return false;\n    }\n\n    // `true` means we use the regular mutation handling by rrweb\n    return true;\n  };}\n}\n\nfunction getOption(\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    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.warn(\n        '[Replay] You are using a deprecated configuration item for privacy. Read the documentation on how to use the new privacy configuration.',\n      );\n    });\n  }\n\n  return allSelectors.join(',');\n}\n\n/**\n * Returns privacy related configuration for use in rrweb\n */\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\nconst replayIntegration$1 = ((options) => {\n  // eslint-disable-next-line deprecation/deprecation\n  return new Replay$1(options);\n}) ;\n\n/**\n * The main replay integration class, to be passed to `init({  integrations: [] })`.\n * @deprecated Use `replayIntegration()` instead.\n */\nclass Replay$1  {\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    // eslint-disable-next-line deprecation/deprecation\n    this.name = Replay$1.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  /**\n   * Initializes replay.\n   */\n   _initialize() {\n    if (!this._replay) {\n      return;\n    }\n\n    // We have to run this in _initialize, because this runs in setTimeout\n    // So when this runs all integrations have been added\n    // Before this, we cannot access integrations on the client,\n    // so we need to mutate the options here\n    this._maybeLoadFromReplayCanvasIntegration();\n\n    this._replay.initializeSampling();\n  }\n\n  /** Setup the integration. */\n   _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\n  /** Get canvas options from ReplayCanvas integration, if it is also added. */\n   _maybeLoadFromReplayCanvasIntegration() {\n    // To save bundle size, we skip checking for stuff here\n    // and instead just try-catch everything - as generally this should all be defined\n    /* eslint-disable @typescript-eslint/no-non-null-assertion */\n    try {\n      const client = getClient();\n      const canvasIntegration = client.getIntegrationByName('ReplayCanvas')\n\n;\n      if (!canvasIntegration) {\n        return;\n      }\n\n      this._replay['_canvas'] = canvasIntegration.getOptions();\n    } catch (e) {\n      // ignore errors here\n    }\n    /* eslint-enable @typescript-eslint/no-non-null-assertion */\n  }\n}Replay$1.__initStatic();\n\n/** Parse Replay-related options from SDK options */\nfunction loadReplayOptionsFromClient(initialOptions) {\n  const client = getClient();\n  const opt = client && (client.getOptions() );\n\n  const finalOptions = { sessionSampleRate: 0, errorSampleRate: 0, ...dropUndefinedKeys(initialOptions) };\n\n  if (!opt) {\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.warn('SDK client is not available.');\n    });\n    return finalOptions;\n  }\n\n  if (\n    initialOptions.sessionSampleRate == null && // TODO remove once deprecated rates are removed\n    initialOptions.errorSampleRate == null && // TODO remove once deprecated rates are removed\n    opt.replaysSessionSampleRate == null &&\n    opt.replaysOnErrorSampleRate == null\n  ) {\n    consoleSandbox(() => {\n      // eslint-disable-next-line no-console\n      console.warn(\n        'Replay is disabled because neither `replaysSessionSampleRate` nor `replaysOnErrorSampleRate` are set.',\n      );\n    });\n  }\n\n  if (typeof opt.replaysSessionSampleRate === 'number') {\n    finalOptions.sessionSampleRate = opt.replaysSessionSampleRate;\n  }\n\n  if (typeof opt.replaysOnErrorSampleRate === 'number') {\n    finalOptions.errorSampleRate = opt.replaysOnErrorSampleRate;\n  }\n\n  return finalOptions;\n}\n\nfunction _getMergedNetworkHeaders(headers) {\n  return [...DEFAULT_NETWORK_HEADERS, ...headers.map(header => header.toLowerCase())];\n}\n\n/**\n * This is a small utility to get a type-safe instance of the Replay integration.\n */\n// eslint-disable-next-line deprecation/deprecation\nfunction getReplay$1() {\n  const client = getClient();\n  return (\n    client && client.getIntegrationByName && client.getIntegrationByName('Replay')\n  );\n}\n\n// eslint-disable-next-line deprecation/deprecation\n\n/** @deprecated Use the export from `@sentry/replay` or from framework-specific SDKs like `@sentry/react` or `@sentry/vue` */\nconst getReplay = getReplay$1;\n\n/** @deprecated Use the export from `@sentry/replay` or from framework-specific SDKs like `@sentry/react` or `@sentry/vue` */\nconst replayIntegration = replayIntegration$1;\n\n/** @deprecated Use the export from `@sentry/replay` or from framework-specific SDKs like `@sentry/react` or `@sentry/vue` */\n// eslint-disable-next-line deprecation/deprecation\nclass Replay extends Replay$1 {}\n\nexport { Replay$1 as InternalReplay, Replay, getReplay, getReplay$1 as internalGetReplay, replayIntegration$1 as internalReplayIntegration, replayIntegration };\n//# sourceMappingURL=index.js.map\n"],"names":["WINDOW","_sentry_utils__WEBPACK_IMPORTED_MODULE_10__","OW","REPLAY_SESSION_KEY","UNABLE_TO_SEND_REPLAY","NETWORK_BODY_MAX_SIZE","CONSOLE_ARG_MAX_SIZE","REPLAY_MAX_EVENT_BUFFER_SIZE","_optionalChain$5","ops","lastAccessLHS","value","i","length","op","fn","args","call","undefined","NodeType$1","isShadowRoot","n","host","_","Boolean","_2","shadowRoot","isNativeShadowDom","Object","prototype","toString","stringifyStylesheet","s","rules","cssRules","cssText","Array","from","stringifyRule","join","includes","replace","error","rule","importStringified","isCSSImportRule","styleSheet","split","statement","JSON","stringify","href","layerName","push","supportsText","media","mediaText","escapeImportStatement","isCSSStyleRule","selectorText","NodeType","Mirror","constructor","this","idNodeMap","Map","nodeMetaMap","WeakMap","getId","lhs","_3","getMeta","_4","_5","id","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","maskInputFn","text","repeat","str","toUpperCase","ORIGINAL_ATTRIBUTE_NAME","getInputType","hasAttribute","getInputValue","el","getAttribute","_id","tagNameRegex","RegExp","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","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","regex","eIndex","classList","elementClassMatchesRegex","e2","needMaskingText","maskTextClass","maskTextSelector","unmaskTextClass","unmaskTextSelector","maskAllText","parentElement","autocomplete","maskDistance","unmaskDistance","e","lowerIfExists","maybeAttr","serializeNodeWithId","options","mirror","blockClass","blockSelector","unblockSelector","skipChild","inlineStylesheet","maskTextFn","slimDOMOptions","dataURLOptions","inlineImages","recordCanvas","onSerialize","onIframeLoad","iframeLoadTimeout","onStylesheetLoad","stylesheetLoadTimeout","keepIframeSrcFn","newlyAddedElement","preserveWhiteSpace","_serializedNode","rootId","docId","getRootId","DOCUMENT_NODE","compatMode","Document","DOCUMENT_TYPE_NODE","DocumentType","publicId","systemId","needBlock","contains","_isBlockedElement","HTMLFormElement","processedTagName","getValidTagName","attributes","len","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","isCustomElement","src","contentDocument","rr_src","customElements","Element","isSVG","ownerSVGElement","isCustom","serializeElementNode","TEXT_NODE","parentTagName","isStyle","isScript","isTextarea","nextSibling","previousSibling","_6","_7","_8","textarea","Text","serializeTextNode","CDATA_SECTION_NODE","CDATA","COMMENT_NODE","Comment","serializeNode","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","_optionalChain$4","on","target","capture","passive","DEPARTED_MIRROR_ACCESS_WARNING","_mirror","map","throttle$1","func","wait","timeout","previous","now","Date","leading","remaining","context","rest","getImplementation","clearTimeout$1","apply","trailing","setTimeout$1","hookSetter","key","d","isRevoked","window","original","getOwnPropertyDescriptor","defineProperty","patch","source","replacement","wrapped","defineProperties","__rrweb_original__","enumerable","Proxy","Reflect","prop","receiver","nowTimestamp","getWindowScroll","left","scrollingElement","pageXOffset","documentElement","body","top","pageYOffset","_9","_10","_11","_12","_13","_14","getWindowHeight","innerHeight","clientHeight","getWindowWidth","innerWidth","clientWidth","closestElementOfNode","isBlocked","checkAncestors","blockedPredicate","isUnblocked","blockDistance","unblockDistance","isIgnored","isAncestorRemoved","legacy_isTouchEvent","event","changedTouches","isSerializedIframe","nodeName","isSerializedStylesheet","hasShadowRoot","_18","getTime","StyleSheetMirror","styleIDMap","idStyleMap","_sentry_utils__WEBPACK_IMPORTED_MODULE_0__","S","newId","getStyle","generateId","getShadowHost","shadowHost","_19","getRootNode","_20","_21","Node","DOCUMENT_FRAGMENT_NODE","inDom","ownerDocument","rootShadowHost","getRootShadowHost","shadowHostInDom","cachedImplementations","cached","impl","sandbox","hidden","head","appendChild","removeChild","bind","EventType","EventType2","IncrementalSource","IncrementalSource2","MouseInteractions","MouseInteractions2","PointerTypes","PointerTypes2","_optionalChain$3","isNodeInLinkedList","DoubleLinkedList","tail","position","Error","current","index","next","addNode","__ln","removeNode","moveKey","parentId","MutationBuffer","frozen","locked","texts","attributeMap","removes","mapRemoves","movedMap","addedSet","Set","movedSet","droppedSet","processMutations","mutations","processMutation","emit","adds","addedIds","addList","getNextId","ns","nextId","pushAdd","currentN","iframeManager","addIframe","stylesheetManager","trackLinkElement","shadowDomManager","addShadowRoot","iframe","childSn","attachIframe","observeAttachShadow","attachLinkElement","shift","isParentRemoved","isAncestorInSet","candidate","tailNode","_node","unhandledNode","payload","filter","attribute","style","diffAsStr","styleDiff","unchangedAsStr","_unchangedStyles","mutationCb","m","attributeName","isInputMasked","item","setAttribute","unattachedDoc","implementation","createHTMLDocument","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","_optionalChain$2","mutationBuffers","getEventTarget","path","composedPath","initMutationObserver","rootEl","mutationBuffer","mutationObserverCtor","MutationObserver","__rrMutationObserver","angularZoneSymbol","Zone","__symbol__","observer","onMutation","observe","attributeOldValue","characterData","characterDataOldValue","childList","subtree","initScrollObserver","scrollCb","sampling","evt","defaultView","scrollLeftTop","scroll","INPUT_TAGS","lastInputValueMap","initInputObserver","inputCb","ignoreClass","ignoreSelector","userTriggeredOnInput","eventHandler","userTriggered","isTrusted","isChecked","cbWithDedup","querySelectorAll","v","lastInputValue","handlers","input","eventName","currentWindow","h","propertyDescriptor","HTMLInputElement","hookProperties","HTMLSelectElement","HTMLTextAreaElement","HTMLOptionElement","p","getNestedCSSRulePositions","childRule","hasNestedCSSRule","parentRule","CSSGroupingRule","CSSMediaRule","CSSSupportsRule","CSSConditionRule","unshift","parentStyleSheet","recurse","getIdAndStyleId","styleMirror","styleId","ownerNode","initAdoptedStyleSheetObserver","hostId","patchTarget","ShadowRoot","originalPropertyDescriptor","configurable","sheets","result","_15","_16","adoptStyleSheets","initObservers","o","_hooks","mutationObserver","mousemoveHandler","mousemoveCb","mousemove","threshold","callbackThreshold","mousemoveCallback","timeBaseline","positions","wrappedCb","totalOffset","timeOffset","updatePosition","clientX","clientY","DragEvent","Drag","MouseEvent","MouseMove","TouchMove","initMoveObserver","mouseInteractionHandler","mouseInteractionCb","mouseInteraction","disableMap","currentPointerType","Number","isNaN","eventKey","pointerType","thisEventKey","Mouse","Touch","Pen","MouseDown","MouseUp","startsWith","Click","getHandler","PointerEvent","TouchStart","TouchEnd","initMouseInteractionObserver","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","_17","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","pluginHandlers","plugin","plugins","callback","b","disconnect","CrossOriginIframeMirror","generateIdFn","iframeIdToRemoteIdMap","iframeRemoteIdToIdMap","remoteId","idToRemoteMap","remoteToIdMap","idToRemoteIdMap","getIdToRemoteIdMap","remoteIdToIdMap","getRemoteIdToIdMap","getRemoteId","getRemoteIds","ids","_optionalChain$1","IframeManagerNoop","crossOriginIframeMirror","crossOriginIframeRootIdMap","addLoadListener","IframeManager","iframes","crossOriginIframeMap","wrappedEmit","recordCrossOriginIframes","crossOriginIframeStyleMirror","handleMessage","loadListener","isAttachIframe","adoptedStyleSheets","message","crossOriginMessageEvent","transformedEvent","transformCrossOriginEvent","isCheckout","FullSnapshot","replaceIdOnNode","patchRootIdOnNode","timestamp","IncrementalSnapshot","Mutation","Meta","Load","DomContentLoaded","Plugin","Custom","replaceIds","ViewportResize","MediaInteraction","MouseInteraction","Scroll","CanvasMutation","Input","StyleSheetRule","StyleDeclaration","replaceStyleIds","Font","Selection","AdoptedStyleSheet","styles","iframeMirror","obj","isArray","child","ShadowDomManagerNoop","ShadowDomManager","shadowDoms","WeakSet","restoreHandlers","patchAttachShadow","iframeElement","manager","option","CanvasManagerNoop","snapshot","StylesheetManager","trackedLinkElements","adoptedStyleSheetCb","linkEl","trackStylesheetInLinkElement","adoptedStyleSheetData","styleIds","CSSRule","ProcessedNodeManager","nodeMap","loop","periodicallyClear","onRequestAnimationFrame","clear","thisBuffer","buffers","destroy","_takeFullSnapshot","record","checkoutEveryNms","checkoutEveryNth","maskAllInputs","_maskInputOptions","_slimDOMOptions","maxCanvasSize","packFn","mousemoveWait","recordAfter","getCanvasManager","inEmittingFrame","parent","passEmitsToParent","color","date","email","month","number","search","tel","time","week","select","radio","checkbox","lastFullSnapshotEvent","NodeList","DOMTokenList","TypeError","polyfill","incrementalSnapshotCount","eventProcessor","_sentry_utils__WEBPACK_IMPORTED_MODULE_1__","z","buf","postMessage","exceedCount","exceedTime","takeFullSnapshot","wrappedMutationEmit","wrappedScrollEmit","wrappedCanvasMutationEmit","__RRWEB_EXCLUDE_IFRAME__","getMirror","nodeMirror","getCanvasManagerFn","_getCanvasManager","__RRWEB_EXCLUDE_SHADOW_DOM__","slimDOM","initialOffset","canvasMutationCb","CustomElement","timestampToMs","timestampToS","addBreadcrumbEvent","replay","breadcrumb","category","triggerUserActivity","checkAndHandleExpiredSession","addUpdate","throttledAddEvent","tag","_sentry_utils__WEBPACK_IMPORTED_MODULE_14__","S8","getClosestInteractive","closest","getClickTargetNode","getTargetNode","isEventWithTarget","ClickDetector","slowClickConfig","_addBreadcrumbEvent","_lastMutation","_lastScroll","_clicks","_timeout","_threshold","_scollTimeout","scrollTimeout","_replay","_ignoreSelector","addListeners","cleanupWindowOpen","nowInSeconds","_sentry_utils__WEBPACK_IMPORTED_MODULE_15__","GS","originalWindowOpen","splice","_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","createBreadcrumb","ATTRIBUTES_TO_RECORD","getAttributesToRecord","normalizedKey","getBaseDomBreadcrumb","isElement","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","_sentry_utils__WEBPACK_IMPORTED_MODULE_17__","k3","performance","timeOrigin","DEBUG_BUILD","__SENTRY_DEBUG__","logInfo","shouldAddBreadcrumb","_sentry_utils__WEBPACK_IMPORTED_MODULE_12__","vF","info","addLogBreadcrumb","logInfoNextTick","_sentry_core__WEBPACK_IMPORTED_MODULE_3__","ZQ","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","then","EventBufferProxy","_fallback","_compression","_used","_ensureWorkerIsLoadedPromise","_ensureWorkerIsLoaded","ensureWorkerIsLoaded","_switchToCompressionWorker","addEventPromises","all","hasSessionStorage","sessionStorage","isSampled","sampleRate","random","makeSession","session","_sentry_utils__WEBPACK_IMPORTED_MODULE_13__","eJ","started","lastActivity","segmentId","sampled","previousSessionId","saveSession","setItem","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","isCustomEvent","maybeApplyCallback","getOptions","beforeAddRecordingEvent","reason","stop","client","KU","recordDroppedEvent","isPaused","isEnabled","timestampInMs","timeouts","sessionIdlePause","initialTimestamp","_experiments","isErrorEvent","isTransactionEvent","isFeedbackEvent","handleAfterSendEvent","enforceStatusCode","transport","getTransport","__sentry__baseTransport__","isBaseTransportSend","sendResponse","replayContext","contexts","trace","trace_id","traceIds","handleTransactionEvent","event_id","errorIds","tags","replayId","beforeErrorSampling","sendBufferedReplayOrFlush","handleErrorEvent","createPerformanceSpans","description","startTimestamp","endTimestamp","addNetworkBreadcrumb","_sentry_core__WEBPACK_IMPORTED_MODULE_7__","A","shouldFilterRequest","getBodySize","textEncoder","encode","URLSearchParams","FormData","formDataStr","_serializeFormData","Blob","ArrayBuffer","byteLength","parseContentLengthHeader","header","parseInt","getBodyString","mergeWarning","warning","headers","_meta","warnings","newMeta","existingWarnings","makeNetworkReplayBreadcrumb","request","Ce","buildSkippedNetworkRequestOrResponse","bodySize","buildNetworkRequestOrResponse","normalizedBody","exceedsSizeLimit","isProbablyJson","first","last","_strIsProbablyJson","truncatedBody","e3","normalizeNetworkBody","getAllowedHeaders","allowedHeaders","reduce","filteredHeaders","formData","urlMatches","urls","fullUrl","baseURI","fixedUrl","URL","getFullUrl","_sentry_utils__WEBPACK_IMPORTED_MODULE_16__","Xr","_getFetchRequestArgBody","fetchArgs","getAllHeaders","allHeaders","getHeadersFromOptions","Headers","handleNetworkBreadcrumbs","TextEncoder","networkDetailAllowUrls","networkDetailDenyUrls","networkCaptureBodies","networkRequestHeaders","networkResponseHeaders","hint","_isXhrBreadcrumb","xhr","_isXhrHint","reqSize","resSize","getResponseHeader","responseType","_getBodySize","request_body_size","response_body_size","enrichXhrBreadcrumb","status_code","requestBodySize","responseBodySize","xhrInfo","_sentry_utils__WEBPACK_IMPORTED_MODULE_21__","Er","request_headers","getAllResponseHeaders","acc","line","getResponseHeaders","requestBody","requestWarning","responseBody","responseWarning","errors","responseText","outerHTML","_parseXhrResponse","_getXhrResponseBody","_prepareXhrData","captureXhrBreadcrumbToReplay","_isFetchBreadcrumb","_isFetchHint","enrichFetchBreadcrumb","captureDetails","bodyStr","_getRequestInfo","bodyText","res","clone","_tryCloneResponse","_getResponseText","txt","finally","_tryGetResponseText","_parseFetchResponseBody","getResponseData","_getResponseInfo","_prepareFetchData","captureFetchBreadcrumbToReplay","beforeAddNetworkBreadcrumb","_sentry_utils__WEBPACK_IMPORTED_MODULE_22__","u","handlerData","fetchData","status","handleFetch","handleFetchSpanListener","Mn","sentryXhrData","handleXhr","handleXhrSpanListener","_LAST_BREADCRUMB","hasHooks","createMemoryEntry","memoryEntry","jsHeapSizeLimit","totalJSHeapSize","usedJSHeapSize","memory","getHandleRecordingEmit","hadFirstEvent","_isCheckout","clickDetector","isIncrementalEvent","isIncrementalMouseInteraction","HTMLElement","updateClickDetectorForRecordingEvent","setInitialState","shouldRecordCanvas","isRecordingCanvas","errorSampleRate","useCompressionOption","useCompression","blockAllMedia","networkDetailHasUrls","networkRequestHasHeaders","networkResponseHasHeaders","createOptionsEvent","addSettingsEvent","earliestEvent","flush","TransportStatusCodeError","RateLimitError","rateLimits","sendReplay","replayData","retryConfig","interval","recordingData","segment_id","eventContext","preparedRecordingData","payloadWithSequence","replayHeaders","sequence","prepareRecordingData","scope","o5","dsn","getDsn","baseEvent","replay_start_timestamp","error_ids","trace_ids","replay_id","replay_type","replayEvent","eventHint","integrations","_integrations","preparedEvent","_sentry_core__WEBPACK_IMPORTED_MODULE_6__","mG","_sentry_core__WEBPACK_IMPORTED_MODULE_4__","rm","platform","metadata","getSdkMetadata","version","sdk","prepareReplayEvent","sdkProcessingMetadata","envelope","tunnel","_sentry_utils__WEBPACK_IMPORTED_MODULE_18__","h4","n2","Cj","createReplayEnvelope","send","cause","_sentry_utils__WEBPACK_IMPORTED_MODULE_19__","wq","Jz","sendReplayRequest","_retryCount","captureExceptions","Cp","THROTTLED","ReplayContainer","recordingOptions","__init","__init2","__init3","__init4","__init5","__init6","performanceEntries","replayPerformanceEntries","_lastActivity","_isEnabled","_isPaused","_hasInitializedCoreListeners","_context","initialUrl","_recordingOptions","_options","_debouncedFlush","callbackReturnValue","timerId","maxTimerId","maxWait","max","invokeFunc","cancelTimers","debounced","cancel","debounce","_flush","flushMinDelay","flushMaxDelay","_throttledAddEvent","maxCount","durationSeconds","counter","isThrottled","floor","_cleanup","values","wasThrottled","throttle","slowClickTimeout","slowClickIgnoreSelectors","_canvas","initializeSampling","_initializeSessionForSampling","_initializeRecording","_handleException","_updateUserActivity","startBuffering","startRecording","canvasOptions","_stopRecording","_onMutationHandler","stopRecording","forceFlush","_removeListeners","force","removeItem","deleteSession","pause","resume","_checkSession","continueRecording","flushImmediate","activityTime","hasStoppedRecording","_updateSessionActivity","_maybeSaveSession","cbResult","updateUserActivity","conditionalFlush","cancelFlush","getSessionId","urlPath","pathname","hash","_clearContext","lastTransaction","getTransaction","_sentry_core__WEBPACK_IMPORTED_MODULE_8__","et","_sentry_core__WEBPACK_IMPORTED_MODULE_2__","i_","workerUrl","customWorkerUrl","Worker","__SENTRY_EXCLUDE_REPLAY_WORKER__","createObjectURL","_loadWorker","createEventBuffer","_addListeners","currentSession","_refreshSession","_handleVisibilityChange","_handleWindowBlur","_handleWindowFocus","_handleKeyboardEvent","addScopeListener","newBreadcrumb","getLastBreadcrumb","arguments","isTruncated","normalizedArgs","normalizedArg","normalizeConsoleBreadcrumb","handleScope","handleScopeListener","_sentry_utils__WEBPACK_IMPORTED_MODULE_20__","isClick","_sentry_utils__WEBPACK_IMPORTED_MODULE_9__","Hd","maxStringLength","getDomTarget","handleDom","altKey","metaKey","ctrlKey","shiftKey","handleDomListener","_sentry_utils__WEBPACK_IMPORTED_MODULE_23__","to","handleHistory","handleHistorySpanListener","includeAfterSendEventHandling","afterSendHandler","isReplayEvent","breadcrumbs","feedback","feedbackId","addFeedbackBreadcrumb","exception","originalException","__rrweb__","isRrwebError","log","isErrorEventSampled","shouldSampleForBufferEvent","handleGlobalEventListener","addEventProcessor","_sentry_core__WEBPACK_IMPORTED_MODULE_5__","exceptionValue","handleHydrationError","handleBeforeSendEvent","dsc","transaction","feedbackEvent","includeReplay","addGlobalListeners","_performanceCleanupCallback","addPerformanceEntry","onEntries","clearCallbacks","_sentry_internal_tracing__WEBPACK_IMPORTED_MODULE_24__","wv","Pt","lastEntry","getLargestContentfulPaint","clearCallback","setupPerformanceObserver","visibilityState","_doChangeToForegroundTasks","_doChangeToBackgroundTasks","isContentEditable","isInputElement","hasModifierKey","isCharacterKey","getKeyboardBreadcrumb","handleKeyboardEvent","_createCustomBreadcrumb","_addPerformanceEntries","concat","_updateInitialTimestampFromEventBuffer","_popEventContext","_runFlush","addMemoryEntry","tooShort","minReplayDuration","tooLong","_flushLock","mutationLimit","overMutationLimit","mutationBreadcrumbLimit","getOption","selectors","defaultSelectors","deprecatedClassOption","deprecatedSelectorOption","allSelectors","pq","MEDIA_SELECTORS","DEFAULT_NETWORK_HEADERS","_initialized","Replay$1","__initStatic","MAX_REPLAY_DURATION","mask","maskAttributes","unmask","block","unblock","ignore","maskFn","privacyOptions","getPrivacyOptions","password","maskAttribute","_initialOptions","_getMergedNetworkHeaders","_isInitialized","_sentry_utils__WEBPACK_IMPORTED_MODULE_11__","B","setupOnce","_setup","_initialize","getReplayId","_maybeLoadFromReplayCanvasIntegration","finalOptions","initialOptions","opt","replaysSessionSampleRate","replaysOnErrorSampleRate","loadReplayOptionsFromClient","canvasIntegration","getIntegrationByName"],"sourceRoot":""}