{"version":3,"file":"static/js/1383_b98cced866979feb399f.js","mappings":"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","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@datadog+browser-rum@4.34.3_vkjwqkjw2ssbpzn25dkdrfjgqi/node_modules/@datadog/browser-rum/esm/boot/recorderApi.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@datadog+browser-rum@4.34.3_vkjwqkjw2ssbpzn25dkdrfjgqi/node_modules/@datadog/browser-rum/esm/constants.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@datadog+browser-rum@4.34.3_vkjwqkjw2ssbpzn25dkdrfjgqi/node_modules/@datadog/browser-rum/esm/domain/record/privacy.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@datadog+browser-rum@4.34.3_vkjwqkjw2ssbpzn25dkdrfjgqi/node_modules/@datadog/browser-rum/esm/domain/record/serializationUtils.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@datadog+browser-rum@4.34.3_vkjwqkjw2ssbpzn25dkdrfjgqi/node_modules/@datadog/browser-rum/esm/domain/record/serialize.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@datadog+browser-rum@4.34.3_vkjwqkjw2ssbpzn25dkdrfjgqi/node_modules/@datadog/browser-rum/esm/domain/record/utils.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@datadog+browser-rum@4.34.3_vkjwqkjw2ssbpzn25dkdrfjgqi/node_modules/@datadog/browser-rum/esm/domain/record/mutationBatch.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@datadog+browser-rum@4.34.3_vkjwqkjw2ssbpzn25dkdrfjgqi/node_modules/@datadog/browser-rum/esm/domain/record/mutationObserver.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@datadog+browser-rum@4.34.3_vkjwqkjw2ssbpzn25dkdrfjgqi/node_modules/@datadog/browser-rum/esm/domain/record/viewports.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@datadog+browser-rum@4.34.3_vkjwqkjw2ssbpzn25dkdrfjgqi/node_modules/@datadog/browser-rum/esm/domain/record/observers.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@datadog+browser-rum@4.34.3_vkjwqkjw2ssbpzn25dkdrfjgqi/node_modules/@datadog/browser-rum/esm/domain/record/shadowRootsController.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@datadog+browser-rum@4.34.3_vkjwqkjw2ssbpzn25dkdrfjgqi/node_modules/@datadog/browser-rum/esm/domain/record/record.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@datadog+browser-rum@4.34.3_vkjwqkjw2ssbpzn25dkdrfjgqi/node_modules/@datadog/browser-rum/esm/domain/record/elementsScrollPositions.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@datadog+browser-rum@4.34.3_vkjwqkjw2ssbpzn25dkdrfjgqi/node_modules/@datadog/browser-rum/esm/boot/startRecording.js","file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/@datadog+browser-rum@4.34.3_vkjwqkjw2ssbpzn25dkdrfjgqi/node_modules/@datadog/browser-rum/esm/domain/replayStats.js"],"sourcesContent":["import { canUseEventBridge, noop, runOnReadyState } from '@datadog/browser-core';\nimport { getReplayStats } from '../domain/replayStats';\nimport { startDeflateWorker } from '../domain/segmentCollection';\nexport function makeRecorderApi(startRecordingImpl, startDeflateWorkerImpl) {\n    if (startDeflateWorkerImpl === void 0) { startDeflateWorkerImpl = startDeflateWorker; }\n    if (canUseEventBridge() || !isBrowserSupported()) {\n        return {\n            start: noop,\n            stop: noop,\n            getReplayStats: function () { return undefined; },\n            onRumStart: noop,\n            isRecording: function () { return false; },\n        };\n    }\n    var state = {\n        status: 0 /* Stopped */,\n    };\n    var startStrategy = function () {\n        state = { status: 1 /* IntentToStart */ };\n    };\n    var stopStrategy = function () {\n        state = { status: 0 /* Stopped */ };\n    };\n    return {\n        start: function () { return startStrategy(); },\n        stop: function () { return stopStrategy(); },\n        getReplayStats: getReplayStats,\n        onRumStart: function (lifeCycle, configuration, sessionManager, viewContexts) {\n            lifeCycle.subscribe(7 /* SESSION_EXPIRED */, function () {\n                if (state.status === 2 /* Starting */ || state.status === 3 /* Started */) {\n                    stopStrategy();\n                    state = { status: 1 /* IntentToStart */ };\n                }\n            });\n            lifeCycle.subscribe(8 /* SESSION_RENEWED */, function () {\n                if (state.status === 1 /* IntentToStart */) {\n                    startStrategy();\n                }\n            });\n            startStrategy = function () {\n                var session = sessionManager.findTrackedSession();\n                if (!session || !session.sessionReplayAllowed) {\n                    state = { status: 1 /* IntentToStart */ };\n                    return;\n                }\n                if (state.status === 2 /* Starting */ || state.status === 3 /* Started */) {\n                    return;\n                }\n                state = { status: 2 /* Starting */ };\n                runOnReadyState('interactive', function () {\n                    if (state.status !== 2 /* Starting */) {\n                        return;\n                    }\n                    startDeflateWorkerImpl(function (worker) {\n                        if (state.status !== 2 /* Starting */) {\n                            return;\n                        }\n                        if (!worker) {\n                            state = {\n                                status: 0 /* Stopped */,\n                            };\n                            return;\n                        }\n                        var stopRecording = startRecordingImpl(lifeCycle, configuration, sessionManager, viewContexts, worker).stop;\n                        state = {\n                            status: 3 /* Started */,\n                            stopRecording: stopRecording,\n                        };\n                    });\n                });\n            };\n            stopStrategy = function () {\n                if (state.status === 0 /* Stopped */) {\n                    return;\n                }\n                if (state.status === 3 /* Started */) {\n                    state.stopRecording();\n                }\n                state = {\n                    status: 0 /* Stopped */,\n                };\n            };\n            if (state.status === 1 /* IntentToStart */) {\n                startStrategy();\n            }\n        },\n        isRecording: function () { return state.status === 3 /* Started */; },\n    };\n}\n/**\n * Test for Browser features used while recording\n */\nfunction isBrowserSupported() {\n    return (\n    // Array.from is a bit less supported by browsers than CSSSupportsRule, but has higher chances\n    // to be polyfilled. Test for both to be more confident. We could add more things if we find out\n    // this test is not sufficient.\n    typeof Array.from === 'function' && typeof CSSSupportsRule === 'function' && 'forEach' in NodeList.prototype);\n}\n//# sourceMappingURL=recorderApi.js.map","import { DefaultPrivacyLevel } from '@datadog/browser-core';\nexport var NodePrivacyLevel = {\n    IGNORE: 'ignore',\n    HIDDEN: 'hidden',\n    ALLOW: DefaultPrivacyLevel.ALLOW,\n    MASK: DefaultPrivacyLevel.MASK,\n    MASK_USER_INPUT: DefaultPrivacyLevel.MASK_USER_INPUT,\n};\nexport var PRIVACY_ATTR_NAME = 'data-dd-privacy';\n// Privacy Attrs\nexport var PRIVACY_ATTR_VALUE_ALLOW = 'allow';\nexport var PRIVACY_ATTR_VALUE_MASK = 'mask';\nexport var PRIVACY_ATTR_VALUE_MASK_USER_INPUT = 'mask-user-input';\nexport var PRIVACY_ATTR_VALUE_HIDDEN = 'hidden';\n// Privacy Classes - not all customers can set plain HTML attributes, so support classes too\nexport var PRIVACY_CLASS_ALLOW = 'dd-privacy-allow';\nexport var PRIVACY_CLASS_MASK = 'dd-privacy-mask';\nexport var PRIVACY_CLASS_MASK_USER_INPUT = 'dd-privacy-mask-user-input';\nexport var PRIVACY_CLASS_HIDDEN = 'dd-privacy-hidden';\n// Private Replacement Templates\nexport var CENSORED_STRING_MARK = '***';\nexport var CENSORED_IMG_MARK = 'data:image/gif;base64,R0lGODlhAQABAIAAAMLCwgAAACH5BAAAAAAALAAAAAABAAEAAAICRAEAOw==';\nexport var FORM_PRIVATE_TAG_NAMES = {\n    INPUT: true,\n    OUTPUT: true,\n    TEXTAREA: true,\n    SELECT: true,\n    OPTION: true,\n    DATALIST: true,\n    OPTGROUP: true,\n};\n//# sourceMappingURL=constants.js.map","import { isElementNode, getParentNode, isTextNode } from '@datadog/browser-rum-core';\nimport { NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_ALLOW, PRIVACY_ATTR_VALUE_MASK, PRIVACY_ATTR_VALUE_MASK_USER_INPUT, PRIVACY_ATTR_VALUE_HIDDEN, PRIVACY_CLASS_ALLOW, PRIVACY_CLASS_MASK, PRIVACY_CLASS_MASK_USER_INPUT, PRIVACY_CLASS_HIDDEN, FORM_PRIVATE_TAG_NAMES, CENSORED_STRING_MARK, } from '../../constants';\nexport var MAX_ATTRIBUTE_VALUE_CHAR_LENGTH = 100000;\nvar TEXT_MASKING_CHAR = 'x';\n/**\n * Get node privacy level by iterating over its ancestors. When the direct parent privacy level is\n * know, it is best to use something like:\n *\n * derivePrivacyLevelGivenParent(getNodeSelfPrivacyLevel(node), parentNodePrivacyLevel)\n */\nexport function getNodePrivacyLevel(node, defaultPrivacyLevel) {\n    var parentNode = getParentNode(node);\n    var parentNodePrivacyLevel = parentNode ? getNodePrivacyLevel(parentNode, defaultPrivacyLevel) : defaultPrivacyLevel;\n    var selfNodePrivacyLevel = getNodeSelfPrivacyLevel(node);\n    return reducePrivacyLevel(selfNodePrivacyLevel, parentNodePrivacyLevel);\n}\n/**\n * Reduces the next privacy level based on self + parent privacy levels\n */\nexport function reducePrivacyLevel(childPrivacyLevel, parentNodePrivacyLevel) {\n    switch (parentNodePrivacyLevel) {\n        // These values cannot be overridden\n        case NodePrivacyLevel.HIDDEN:\n        case NodePrivacyLevel.IGNORE:\n            return parentNodePrivacyLevel;\n    }\n    switch (childPrivacyLevel) {\n        case NodePrivacyLevel.ALLOW:\n        case NodePrivacyLevel.MASK:\n        case NodePrivacyLevel.MASK_USER_INPUT:\n        case NodePrivacyLevel.HIDDEN:\n        case NodePrivacyLevel.IGNORE:\n            return childPrivacyLevel;\n        default:\n            return parentNodePrivacyLevel;\n    }\n}\n/**\n * Determines the node's own privacy level without checking for ancestors.\n */\nexport function getNodeSelfPrivacyLevel(node) {\n    // Only Element types can have a privacy level set\n    if (!isElementNode(node)) {\n        return;\n    }\n    var privAttr = node.getAttribute(PRIVACY_ATTR_NAME);\n    // Overrules for replay purpose\n    if (node.tagName === 'BASE') {\n        return NodePrivacyLevel.ALLOW;\n    }\n    // Overrules to enforce end-user protection\n    if (node.tagName === 'INPUT') {\n        var inputElement = node;\n        if (inputElement.type === 'password' || inputElement.type === 'email' || inputElement.type === 'tel') {\n            return NodePrivacyLevel.MASK;\n        }\n        if (inputElement.type === 'hidden') {\n            return NodePrivacyLevel.MASK;\n        }\n        var autocomplete = inputElement.getAttribute('autocomplete');\n        // Handle input[autocomplete=cc-number/cc-csc/cc-exp/cc-exp-month/cc-exp-year]\n        if (autocomplete && autocomplete.indexOf('cc-') === 0) {\n            return NodePrivacyLevel.MASK;\n        }\n    }\n    // Check HTML privacy attributes and classes\n    if (privAttr === PRIVACY_ATTR_VALUE_HIDDEN || node.classList.contains(PRIVACY_CLASS_HIDDEN)) {\n        return NodePrivacyLevel.HIDDEN;\n    }\n    if (privAttr === PRIVACY_ATTR_VALUE_MASK || node.classList.contains(PRIVACY_CLASS_MASK)) {\n        return NodePrivacyLevel.MASK;\n    }\n    if (privAttr === PRIVACY_ATTR_VALUE_MASK_USER_INPUT || node.classList.contains(PRIVACY_CLASS_MASK_USER_INPUT)) {\n        return NodePrivacyLevel.MASK_USER_INPUT;\n    }\n    if (privAttr === PRIVACY_ATTR_VALUE_ALLOW || node.classList.contains(PRIVACY_CLASS_ALLOW)) {\n        return NodePrivacyLevel.ALLOW;\n    }\n    if (shouldIgnoreElement(node)) {\n        return NodePrivacyLevel.IGNORE;\n    }\n}\n/**\n * Helper aiming to unify `mask` and `mask-user-input` privacy levels:\n *\n * In the `mask` case, it is trivial: we should mask the element.\n *\n * In the `mask-user-input` case, we should mask the element only if it is a \"form\" element or the\n * direct parent is a form element for text nodes).\n *\n * Other `shouldMaskNode` cases are edge cases that should not matter too much (ex: should we mask a\n * node if it is ignored or hidden? it doesn't matter since it won't be serialized).\n */\nexport function shouldMaskNode(node, privacyLevel) {\n    switch (privacyLevel) {\n        case NodePrivacyLevel.MASK:\n        case NodePrivacyLevel.HIDDEN:\n        case NodePrivacyLevel.IGNORE:\n            return true;\n        case NodePrivacyLevel.MASK_USER_INPUT:\n            return isTextNode(node) ? isFormElement(node.parentNode) : isFormElement(node);\n        default:\n            return false;\n    }\n}\nfunction isFormElement(node) {\n    if (!node || node.nodeType !== node.ELEMENT_NODE) {\n        return false;\n    }\n    var element = node;\n    if (element.tagName === 'INPUT') {\n        switch (element.type) {\n            case 'button':\n            case 'color':\n            case 'reset':\n            case 'submit':\n                return false;\n        }\n    }\n    return !!FORM_PRIVATE_TAG_NAMES[element.tagName];\n}\n/**\n * Text censoring non-destructively maintains whitespace characters in order to preserve text shape\n * during replay.\n */\nexport var censorText = function (text) { return text.replace(/\\S/g, TEXT_MASKING_CHAR); };\nexport function getTextContent(textNode, ignoreWhiteSpace, parentNodePrivacyLevel) {\n    var _a;\n    // The parent node may not be a html element which has a tagName attribute.\n    // So just let it be undefined which is ok in this use case.\n    var parentTagName = (_a = textNode.parentElement) === null || _a === void 0 ? void 0 : _a.tagName;\n    var textContent = textNode.textContent || '';\n    if (ignoreWhiteSpace && !textContent.trim()) {\n        return;\n    }\n    var nodePrivacyLevel = parentNodePrivacyLevel;\n    var isStyle = parentTagName === 'STYLE' ? true : undefined;\n    var isScript = parentTagName === 'SCRIPT';\n    if (isScript) {\n        // For perf reasons, we don't record script (heuristic)\n        textContent = CENSORED_STRING_MARK;\n    }\n    else if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        // Should never occur, but just in case, we set to CENSORED_MARK.\n        textContent = CENSORED_STRING_MARK;\n    }\n    else if (shouldMaskNode(textNode, nodePrivacyLevel) &&\n        // Style tags are `overruled` (Use `hide` to enforce privacy)\n        !isStyle) {\n        if (\n        // Scrambling the child list breaks text nodes for DATALIST/SELECT/OPTGROUP\n        parentTagName === 'DATALIST' ||\n            parentTagName === 'SELECT' ||\n            parentTagName === 'OPTGROUP') {\n            if (!textContent.trim()) {\n                return;\n            }\n        }\n        else if (parentTagName === 'OPTION') {\n            // <Option> has low entropy in charset + text length, so use `CENSORED_STRING_MARK` when masked\n            textContent = CENSORED_STRING_MARK;\n        }\n        else {\n            textContent = censorText(textContent);\n        }\n    }\n    return textContent;\n}\n/**\n * TODO: Preserve CSS element order, and record the presence of the tag, just don't render\n * We don't need this logic on the recorder side.\n * For security related meta's, customer can mask themmanually given they\n * are easy to identify in the HEAD tag.\n */\nexport function shouldIgnoreElement(element) {\n    if (element.nodeName === 'SCRIPT') {\n        return true;\n    }\n    if (element.nodeName === 'LINK') {\n        var relAttribute = getLowerCaseAttribute('rel');\n        return (\n        // Link as script - Ignore only when rel=preload, modulepreload or prefetch\n        (/preload|prefetch/i.test(relAttribute) && getLowerCaseAttribute('as') === 'script') ||\n            // Favicons\n            relAttribute === 'shortcut icon' ||\n            relAttribute === 'icon');\n    }\n    if (element.nodeName === 'META') {\n        var nameAttribute = getLowerCaseAttribute('name');\n        var relAttribute = getLowerCaseAttribute('rel');\n        var propertyAttribute = getLowerCaseAttribute('property');\n        return (\n        // Favicons\n        /^msapplication-tile(image|color)$/.test(nameAttribute) ||\n            nameAttribute === 'application-name' ||\n            relAttribute === 'icon' ||\n            relAttribute === 'apple-touch-icon' ||\n            relAttribute === 'shortcut icon' ||\n            // Description\n            nameAttribute === 'keywords' ||\n            nameAttribute === 'description' ||\n            // Social\n            /^(og|twitter|fb):/.test(propertyAttribute) ||\n            /^(og|twitter):/.test(nameAttribute) ||\n            nameAttribute === 'pinterest' ||\n            // Robots\n            nameAttribute === 'robots' ||\n            nameAttribute === 'googlebot' ||\n            nameAttribute === 'bingbot' ||\n            // Http headers. Ex: X-UA-Compatible, Content-Type, Content-Language, cache-control,\n            // X-Translated-By\n            element.hasAttribute('http-equiv') ||\n            // Authorship\n            nameAttribute === 'author' ||\n            nameAttribute === 'generator' ||\n            nameAttribute === 'framework' ||\n            nameAttribute === 'publisher' ||\n            nameAttribute === 'progid' ||\n            /^article:/.test(propertyAttribute) ||\n            /^product:/.test(propertyAttribute) ||\n            // Verification\n            nameAttribute === 'google-site-verification' ||\n            nameAttribute === 'yandex-verification' ||\n            nameAttribute === 'csrf-token' ||\n            nameAttribute === 'p:domain_verify' ||\n            nameAttribute === 'verify-v1' ||\n            nameAttribute === 'verification' ||\n            nameAttribute === 'shopify-checkout-api-token');\n    }\n    function getLowerCaseAttribute(name) {\n        return (element.getAttribute(name) || '').toLowerCase();\n    }\n    return false;\n}\n//# sourceMappingURL=privacy.js.map","import { buildUrl } from '@datadog/browser-core';\nimport { getParentNode, isNodeShadowRoot } from '@datadog/browser-rum-core';\nimport { CENSORED_STRING_MARK } from '../../constants';\nimport { shouldMaskNode } from './privacy';\nvar serializedNodeIds = new WeakMap();\nexport function hasSerializedNode(node) {\n    return serializedNodeIds.has(node);\n}\nexport function nodeAndAncestorsHaveSerializedNode(node) {\n    var current = node;\n    while (current) {\n        if (!hasSerializedNode(current) && !isNodeShadowRoot(current)) {\n            return false;\n        }\n        current = getParentNode(current);\n    }\n    return true;\n}\nexport function getSerializedNodeId(node) {\n    return serializedNodeIds.get(node);\n}\nexport function setSerializedNodeId(node, serializeNodeId) {\n    serializedNodeIds.set(node, serializeNodeId);\n}\n/**\n * Get the element \"value\" to be serialized as an attribute or an input update record. It respects\n * the input privacy mode of the element.\n * PERFROMANCE OPTIMIZATION: Assumes that privacy level `HIDDEN` is never encountered because of earlier checks.\n */\nexport function getElementInputValue(element, nodePrivacyLevel) {\n    /*\n     BROWSER SPEC NOTE: <input>, <select>\n     For some <input> elements, the `value` is an exceptional property/attribute that has the\n     value synced between el.value and el.getAttribute()\n     input[type=button,checkbox,hidden,image,radio,reset,submit]\n     */\n    var tagName = element.tagName;\n    var value = element.value;\n    if (shouldMaskNode(element, nodePrivacyLevel)) {\n        var type = element.type;\n        if (tagName === 'INPUT' && (type === 'button' || type === 'submit' || type === 'reset')) {\n            // Overrule `MASK` privacy level for button-like element values, as they are used during replay\n            // to display their label. They can still be hidden via the \"hidden\" privacy attribute or class name.\n            return value;\n        }\n        else if (!value || tagName === 'OPTION') {\n            // <Option> value provides no benefit\n            return;\n        }\n        return CENSORED_STRING_MARK;\n    }\n    if (tagName === 'OPTION' || tagName === 'SELECT') {\n        return element.value;\n    }\n    if (tagName !== 'INPUT' && tagName !== 'TEXTAREA') {\n        return;\n    }\n    return value;\n}\nexport var URL_IN_CSS_REF = /url\\((?:(')([^']*)'|(\")([^\"]*)\"|([^)]*))\\)/gm;\nexport var ABSOLUTE_URL = /^[A-Za-z]+:|^\\/\\//;\nexport var DATA_URI = /^data:.*,/i;\nexport function switchToAbsoluteUrl(cssText, cssHref) {\n    return cssText.replace(URL_IN_CSS_REF, function (matchingSubstring, singleQuote, urlWrappedInSingleQuotes, doubleQuote, urlWrappedInDoubleQuotes, urlNotWrappedInQuotes) {\n        var url = urlWrappedInSingleQuotes || urlWrappedInDoubleQuotes || urlNotWrappedInQuotes;\n        if (!cssHref || !url || ABSOLUTE_URL.test(url) || DATA_URI.test(url)) {\n            return matchingSubstring;\n        }\n        var quote = singleQuote || doubleQuote || '';\n        return \"url(\".concat(quote).concat(makeUrlAbsolute(url, cssHref)).concat(quote, \")\");\n    });\n}\nexport function makeUrlAbsolute(url, baseUrl) {\n    try {\n        return buildUrl(url, baseUrl).href;\n    }\n    catch (_) {\n        return url;\n    }\n}\nexport function serializeStyleSheets(cssStyleSheets) {\n    if (cssStyleSheets === undefined || cssStyleSheets.length === 0) {\n        return undefined;\n    }\n    return cssStyleSheets.map(function (cssStyleSheet) {\n        var rules = cssStyleSheet.cssRules || cssStyleSheet.rules;\n        var cssRules = Array.from(rules, function (cssRule) { return cssRule.cssText; });\n        var styleSheet = {\n            cssRules: cssRules,\n            disabled: cssStyleSheet.disabled || undefined,\n            media: cssStyleSheet.media.length > 0 ? Array.from(cssStyleSheet.media) : undefined,\n        };\n        return styleSheet;\n    });\n}\n//# sourceMappingURL=serializationUtils.js.map","import { assign, startsWith } from '@datadog/browser-core';\nimport { isNodeShadowHost, isNodeShadowRoot, STABLE_ATTRIBUTES } from '@datadog/browser-rum-core';\nimport { NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_HIDDEN, CENSORED_STRING_MARK, CENSORED_IMG_MARK, } from '../../constants';\nimport { NodeType } from '../../types';\nimport { getTextContent, shouldMaskNode, reducePrivacyLevel, getNodeSelfPrivacyLevel, MAX_ATTRIBUTE_VALUE_CHAR_LENGTH, } from './privacy';\nimport { getSerializedNodeId, setSerializedNodeId, getElementInputValue, switchToAbsoluteUrl, serializeStyleSheets, } from './serializationUtils';\nexport function serializeDocument(document, configuration, serializationContext) {\n    // We are sure that Documents are never ignored, so this function never returns null\n    return serializeNodeWithId(document, {\n        serializationContext: serializationContext,\n        parentNodePrivacyLevel: configuration.defaultPrivacyLevel,\n        configuration: configuration,\n    });\n}\nexport function serializeNodeWithId(node, options) {\n    var serializedNode = serializeNode(node, options);\n    if (!serializedNode) {\n        return null;\n    }\n    // Try to reuse the previous id\n    var id = getSerializedNodeId(node) || generateNextId();\n    var serializedNodeWithId = serializedNode;\n    serializedNodeWithId.id = id;\n    setSerializedNodeId(node, id);\n    if (options.serializedNodeIds) {\n        options.serializedNodeIds.add(id);\n    }\n    return serializedNodeWithId;\n}\nfunction serializeNode(node, options) {\n    switch (node.nodeType) {\n        case node.DOCUMENT_NODE:\n            return serializeDocumentNode(node, options);\n        case node.DOCUMENT_FRAGMENT_NODE:\n            return serializeDocumentFragmentNode(node, options);\n        case node.DOCUMENT_TYPE_NODE:\n            return serializeDocumentTypeNode(node);\n        case node.ELEMENT_NODE:\n            return serializeElementNode(node, options);\n        case node.TEXT_NODE:\n            return serializeTextNode(node, options);\n        case node.CDATA_SECTION_NODE:\n            return serializeCDataNode();\n    }\n}\nexport function serializeDocumentNode(document, options) {\n    return {\n        type: NodeType.Document,\n        childNodes: serializeChildNodes(document, options),\n        adoptedStyleSheets: serializeStyleSheets(document.adoptedStyleSheets),\n    };\n}\nfunction serializeDocumentTypeNode(documentType) {\n    return {\n        type: NodeType.DocumentType,\n        name: documentType.name,\n        publicId: documentType.publicId,\n        systemId: documentType.systemId,\n    };\n}\nfunction serializeDocumentFragmentNode(element, options) {\n    var childNodes = [];\n    if (element.childNodes.length) {\n        childNodes = serializeChildNodes(element, options);\n    }\n    var isShadowRoot = isNodeShadowRoot(element);\n    if (isShadowRoot) {\n        options.serializationContext.shadowRootsController.addShadowRoot(element);\n    }\n    return {\n        type: NodeType.DocumentFragment,\n        childNodes: childNodes,\n        isShadowRoot: isShadowRoot,\n        adoptedStyleSheets: isShadowRoot\n            ? serializeStyleSheets(element.adoptedStyleSheets)\n            : undefined,\n    };\n}\n/**\n * Serializing Element nodes involves capturing:\n * 1. HTML ATTRIBUTES:\n * 2. JS STATE:\n * - scroll offsets\n * - Form fields (input value, checkbox checked, option selection, range)\n * - Canvas state,\n * - Media (video/audio) play mode + currentTime\n * - iframe contents\n * - webcomponents\n * 3. CUSTOM PROPERTIES:\n * - height+width for when `hidden` to cover the element\n * 4. EXCLUDED INTERACTION STATE:\n * - focus (possible, but not worth perf impact)\n * - hover (tracked only via mouse activity)\n * - fullscreen mode\n */\nexport function serializeElementNode(element, options) {\n    var _a;\n    var tagName = getValidTagName(element.tagName);\n    var isSVG = isSVGElement(element) || undefined;\n    // For performance reason, we don't use getNodePrivacyLevel directly: we leverage the\n    // parentNodePrivacyLevel option to avoid iterating over all parents\n    var nodePrivacyLevel = reducePrivacyLevel(getNodeSelfPrivacyLevel(element), options.parentNodePrivacyLevel);\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        var _b = element.getBoundingClientRect(), width = _b.width, height = _b.height;\n        return {\n            type: NodeType.Element,\n            tagName: tagName,\n            attributes: (_a = {\n                    rr_width: \"\".concat(width, \"px\"),\n                    rr_height: \"\".concat(height, \"px\")\n                },\n                _a[PRIVACY_ATTR_NAME] = PRIVACY_ATTR_VALUE_HIDDEN,\n                _a),\n            childNodes: [],\n            isSVG: isSVG,\n        };\n    }\n    // Ignore Elements like Script and some Link, Metas\n    if (nodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n        return;\n    }\n    var attributes = getAttributesForPrivacyLevel(element, nodePrivacyLevel, options);\n    var childNodes = [];\n    if (element.childNodes.length) {\n        // OBJECT POOLING OPTIMIZATION:\n        // We should not create a new object systematically as it could impact performances. Try to reuse\n        // the same object as much as possible, and clone it only if we need to.\n        var childNodesSerializationOptions = void 0;\n        if (options.parentNodePrivacyLevel === nodePrivacyLevel && options.ignoreWhiteSpace === (tagName === 'head')) {\n            childNodesSerializationOptions = options;\n        }\n        else {\n            childNodesSerializationOptions = assign({}, options, {\n                parentNodePrivacyLevel: nodePrivacyLevel,\n                ignoreWhiteSpace: tagName === 'head',\n            });\n        }\n        childNodes = serializeChildNodes(element, childNodesSerializationOptions);\n    }\n    if (isNodeShadowHost(element)) {\n        var shadowRoot = serializeNodeWithId(element.shadowRoot, options);\n        if (shadowRoot !== null) {\n            childNodes.push(shadowRoot);\n        }\n    }\n    return {\n        type: NodeType.Element,\n        tagName: tagName,\n        attributes: attributes,\n        childNodes: childNodes,\n        isSVG: isSVG,\n    };\n}\n/**\n * Text Nodes are dependant on Element nodes\n * Privacy levels are set on elements so we check the parentElement of a text node\n * for privacy level.\n */\nfunction serializeTextNode(textNode, options) {\n    var _a;\n    // The parent node may not be a html element which has a tagName attribute.\n    // So just let it be undefined which is ok in this use case.\n    var parentTagName = (_a = textNode.parentElement) === null || _a === void 0 ? void 0 : _a.tagName;\n    var textContent = getTextContent(textNode, options.ignoreWhiteSpace || false, options.parentNodePrivacyLevel);\n    if (!textContent) {\n        return;\n    }\n    return {\n        type: NodeType.Text,\n        textContent: textContent,\n        isStyle: parentTagName === 'STYLE' ? true : undefined,\n    };\n}\nfunction serializeCDataNode() {\n    return {\n        type: NodeType.CDATA,\n        textContent: '',\n    };\n}\nexport function serializeChildNodes(node, options) {\n    var result = [];\n    node.childNodes.forEach(function (childNode) {\n        var serializedChildNode = serializeNodeWithId(childNode, options);\n        if (serializedChildNode) {\n            result.push(serializedChildNode);\n        }\n    });\n    return result;\n}\nexport function serializeAttribute(element, nodePrivacyLevel, attributeName, configuration) {\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        // dup condition for direct access case\n        return null;\n    }\n    var attributeValue = element.getAttribute(attributeName);\n    if (nodePrivacyLevel === NodePrivacyLevel.MASK &&\n        attributeName !== PRIVACY_ATTR_NAME &&\n        !STABLE_ATTRIBUTES.includes(attributeName) &&\n        attributeName !== configuration.actionNameAttribute) {\n        var tagName = element.tagName;\n        switch (attributeName) {\n            // Mask Attribute text content\n            case 'title':\n            case 'alt':\n            case 'placeholder':\n                return CENSORED_STRING_MARK;\n        }\n        // mask image URLs\n        if (tagName === 'IMG' || tagName === 'SOURCE') {\n            if (attributeName === 'src' || attributeName === 'srcset') {\n                return CENSORED_IMG_MARK;\n            }\n        }\n        // mask <a> URLs\n        if (tagName === 'A' && attributeName === 'href') {\n            return CENSORED_STRING_MARK;\n        }\n        // mask data-* attributes\n        if (attributeValue && startsWith(attributeName, 'data-')) {\n            // Exception: it's safe to reveal the `${PRIVACY_ATTR_NAME}` attr\n            return CENSORED_STRING_MARK;\n        }\n    }\n    if (!attributeValue || typeof attributeValue !== 'string') {\n        return attributeValue;\n    }\n    // Minimum Fix for customer.\n    if (attributeValue.length > MAX_ATTRIBUTE_VALUE_CHAR_LENGTH && attributeValue.slice(0, 5) === 'data:') {\n        return 'data:truncated';\n    }\n    return attributeValue;\n}\nvar _nextId = 1;\nfunction generateNextId() {\n    return _nextId++;\n}\nvar TAG_NAME_REGEX = /[^a-z1-6-_]/;\nfunction getValidTagName(tagName) {\n    var processedTagName = tagName.toLowerCase().trim();\n    if (TAG_NAME_REGEX.test(processedTagName)) {\n        // if the tag name is odd and we cannot extract\n        // anything from the string, then we return a\n        // generic div\n        return 'div';\n    }\n    return processedTagName;\n}\nfunction getCssRulesString(cssStyleSheet) {\n    if (!cssStyleSheet) {\n        return null;\n    }\n    var rules;\n    try {\n        rules = cssStyleSheet.rules || cssStyleSheet.cssRules;\n    }\n    catch (_a) {\n        // if css is protected by CORS we cannot access cssRules see: https://www.w3.org/TR/cssom-1/#the-cssstylesheet-interface\n    }\n    if (!rules) {\n        return null;\n    }\n    var styleSheetCssText = Array.from(rules, getCssRuleString).join('');\n    return switchToAbsoluteUrl(styleSheetCssText, cssStyleSheet.href);\n}\nfunction getCssRuleString(rule) {\n    return isCSSImportRule(rule) ? getCssRulesString(rule.styleSheet) || '' : rule.cssText;\n}\nfunction isCSSImportRule(rule) {\n    return 'styleSheet' in rule;\n}\nfunction isSVGElement(el) {\n    return el.tagName === 'svg' || el instanceof SVGElement;\n}\nfunction getAttributesForPrivacyLevel(element, nodePrivacyLevel, options) {\n    var _a;\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        return {};\n    }\n    var safeAttrs = {};\n    var tagName = getValidTagName(element.tagName);\n    var doc = element.ownerDocument;\n    for (var i = 0; i < element.attributes.length; i += 1) {\n        var attribute = element.attributes.item(i);\n        var attributeName = attribute.name;\n        var attributeValue = serializeAttribute(element, nodePrivacyLevel, attributeName, options.configuration);\n        if (attributeValue !== null) {\n            safeAttrs[attributeName] = attributeValue;\n        }\n    }\n    if (element.value &&\n        (tagName === 'textarea' || tagName === 'select' || tagName === 'option' || tagName === 'input')) {\n        var formValue = getElementInputValue(element, nodePrivacyLevel);\n        if (formValue !== undefined) {\n            safeAttrs.value = formValue;\n        }\n    }\n    /**\n     * <Option> can be selected, which occurs if its `value` matches ancestor `<Select>.value`\n     */\n    if (tagName === 'option' && nodePrivacyLevel === NodePrivacyLevel.ALLOW) {\n        // For privacy=`MASK`, all the values would be the same, so skip.\n        var optionElement = element;\n        if (optionElement.selected) {\n            safeAttrs.selected = optionElement.selected;\n        }\n    }\n    // remote css\n    if (tagName === 'link') {\n        var stylesheet = Array.from(doc.styleSheets).find(function (s) { return s.href === element.href; });\n        var cssText = getCssRulesString(stylesheet);\n        if (cssText && stylesheet) {\n            safeAttrs._cssText = cssText;\n        }\n    }\n    // dynamic stylesheet\n    if (tagName === 'style' &&\n        element.sheet &&\n        // TODO: Currently we only try to get dynamic stylesheet when it is an empty style element\n        !(element.innerText || element.textContent || '').trim().length) {\n        var cssText = getCssRulesString(element.sheet);\n        if (cssText) {\n            safeAttrs._cssText = cssText;\n        }\n    }\n    /**\n     * Forms: input[type=checkbox,radio]\n     * The `checked` property for <input> is a little bit special:\n     * 1. el.checked is a setter that returns if truthy.\n     * 2. getAttribute returns the string value\n     * getAttribute('checked') does not sync with `Element.checked`, so use JS property\n     * NOTE: `checked` property exists on `HTMLInputElement`. For serializer assumptions, we check for type=radio|check.\n     */\n    var inputElement = element;\n    if (tagName === 'input' && (inputElement.type === 'radio' || inputElement.type === 'checkbox')) {\n        if (nodePrivacyLevel === NodePrivacyLevel.ALLOW) {\n            safeAttrs.checked = !!inputElement.checked;\n        }\n        else if (shouldMaskNode(inputElement, nodePrivacyLevel)) {\n            delete safeAttrs.checked;\n        }\n    }\n    /**\n     * Serialize the media playback state\n     */\n    if (tagName === 'audio' || tagName === 'video') {\n        var mediaElement = element;\n        safeAttrs.rr_mediaState = mediaElement.paused ? 'paused' : 'played';\n    }\n    /**\n     * Serialize the scroll state for each element only for full snapshot\n     */\n    var scrollTop;\n    var scrollLeft;\n    var serializationContext = options.serializationContext;\n    switch (serializationContext.status) {\n        case 0 /* INITIAL_FULL_SNAPSHOT */:\n            scrollTop = Math.round(element.scrollTop);\n            scrollLeft = Math.round(element.scrollLeft);\n            if (scrollTop || scrollLeft) {\n                serializationContext.elementsScrollPositions.set(element, { scrollTop: scrollTop, scrollLeft: scrollLeft });\n            }\n            break;\n        case 1 /* SUBSEQUENT_FULL_SNAPSHOT */:\n            if (serializationContext.elementsScrollPositions.has(element)) {\n                ;\n                (_a = serializationContext.elementsScrollPositions.get(element), scrollTop = _a.scrollTop, scrollLeft = _a.scrollLeft);\n            }\n            break;\n    }\n    if (scrollLeft) {\n        safeAttrs.rr_scrollLeft = scrollLeft;\n    }\n    if (scrollTop) {\n        safeAttrs.rr_scrollTop = scrollTop;\n    }\n    return safeAttrs;\n}\n//# sourceMappingURL=serialize.js.map","import { assign, timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nexport function isTouchEvent(event) {\n    return Boolean(event.changedTouches);\n}\nexport function forEach(list, callback) {\n    Array.prototype.forEach.call(list, callback);\n}\nexport function assembleIncrementalSnapshot(source, data) {\n    return {\n        data: assign({\n            source: source,\n        }, data),\n        type: RecordType.IncrementalSnapshot,\n        timestamp: timeStampNow(),\n    };\n}\nexport function getPathToNestedCSSRule(rule) {\n    var path = [];\n    var currentRule = rule;\n    while (currentRule.parentRule) {\n        var rules_1 = Array.from(currentRule.parentRule.cssRules);\n        var index_1 = rules_1.indexOf(currentRule);\n        path.unshift(index_1);\n        currentRule = currentRule.parentRule;\n    }\n    // A rule may not be attached to a stylesheet\n    if (!currentRule.parentStyleSheet) {\n        return;\n    }\n    var rules = Array.from(currentRule.parentStyleSheet.cssRules);\n    var index = rules.indexOf(currentRule);\n    path.unshift(index);\n    return path;\n}\n//# sourceMappingURL=utils.js.map","import { noop, requestIdleCallback } from '@datadog/browser-core';\n/**\n * Maximum duration to wait before processing mutations. If the browser is idle, mutations will be\n * processed more quickly. If the browser is busy executing small tasks (ex: rendering frames), the\n * mutations will wait MUTATION_PROCESS_MAX_DELAY milliseconds before being processed. If the\n * browser is busy executing a longer task, mutations will be processed after this task.\n */\nvar MUTATION_PROCESS_MAX_DELAY = 100;\nexport function createMutationBatch(processMutationBatch) {\n    var cancelScheduledFlush = noop;\n    var pendingMutations = [];\n    function flush() {\n        cancelScheduledFlush();\n        processMutationBatch(pendingMutations);\n        pendingMutations = [];\n    }\n    return {\n        addMutations: function (mutations) {\n            if (pendingMutations.length === 0) {\n                cancelScheduledFlush = requestIdleCallback(flush, { timeout: MUTATION_PROCESS_MAX_DELAY });\n            }\n            pendingMutations.push.apply(pendingMutations, mutations);\n        },\n        flush: flush,\n        stop: function () {\n            cancelScheduledFlush();\n        },\n    };\n}\n//# sourceMappingURL=mutationBatch.js.map","import { monitor, noop } from '@datadog/browser-core';\nimport { getChildNodes, isNodeShadowHost, getMutationObserverConstructor, getParentNode, } from '@datadog/browser-rum-core';\nimport { NodePrivacyLevel } from '../../constants';\nimport { getNodePrivacyLevel, getTextContent } from './privacy';\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode, nodeAndAncestorsHaveSerializedNode, } from './serializationUtils';\nimport { serializeNodeWithId, serializeAttribute } from './serialize';\nimport { createMutationBatch } from './mutationBatch';\n/**\n * Buffers and aggregate mutations generated by a MutationObserver into MutationPayload\n */\nexport function startMutationObserver(mutationCallback, configuration, shadowRootsController, target) {\n    var MutationObserver = getMutationObserverConstructor();\n    if (!MutationObserver) {\n        return { stop: noop, flush: noop };\n    }\n    var mutationBatch = createMutationBatch(function (mutations) {\n        processMutations(mutations.concat(observer.takeRecords()), mutationCallback, configuration, shadowRootsController, target);\n    });\n    var observer = new MutationObserver(monitor(mutationBatch.addMutations));\n    observer.observe(target, {\n        attributeOldValue: true,\n        attributes: true,\n        characterData: true,\n        characterDataOldValue: true,\n        childList: true,\n        subtree: true,\n    });\n    return {\n        stop: function () {\n            observer.disconnect();\n            mutationBatch.stop();\n        },\n        flush: function () {\n            mutationBatch.flush();\n        },\n    };\n}\nfunction processMutations(mutations, mutationCallback, configuration, shadowRootsController, target) {\n    mutations\n        .filter(function (mutation) { return mutation.type === 'childList'; })\n        .forEach(function (mutation) {\n        mutation.removedNodes.forEach(function (removedNode) {\n            traverseRemovedShadowDom(removedNode, shadowRootsController.removeShadowRoot);\n        });\n    });\n    // Discard any mutation with a 'target' node that:\n    // * isn't injected in the current document or isn't known/serialized yet: those nodes are likely\n    // part of a mutation occurring in a parent Node\n    // * should be hidden or ignored\n    var filteredMutations = mutations.filter(function (mutation) {\n        return target.contains(mutation.target) &&\n            nodeAndAncestorsHaveSerializedNode(mutation.target) &&\n            getNodePrivacyLevel(mutation.target, configuration.defaultPrivacyLevel) !== NodePrivacyLevel.HIDDEN;\n    });\n    var _a = processChildListMutations(filteredMutations.filter(function (mutation) { return mutation.type === 'childList'; }), configuration, shadowRootsController), adds = _a.adds, removes = _a.removes, hasBeenSerialized = _a.hasBeenSerialized;\n    var texts = processCharacterDataMutations(filteredMutations.filter(function (mutation) {\n        return mutation.type === 'characterData' && !hasBeenSerialized(mutation.target);\n    }), configuration);\n    var attributes = processAttributesMutations(filteredMutations.filter(function (mutation) {\n        return mutation.type === 'attributes' && !hasBeenSerialized(mutation.target);\n    }), configuration);\n    if (!texts.length && !attributes.length && !removes.length && !adds.length) {\n        return;\n    }\n    mutationCallback({\n        adds: adds,\n        removes: removes,\n        texts: texts,\n        attributes: attributes,\n    });\n}\nfunction processChildListMutations(mutations, configuration, shadowRootsController) {\n    // First, we iterate over mutations to collect:\n    //\n    // * nodes that have been added in the document and not removed by a subsequent mutation\n    // * nodes that have been removed from the document but were not added in a previous mutation\n    //\n    // For this second category, we also collect their previous parent (mutation.target) because we'll\n    // need it to emit a 'remove' mutation.\n    //\n    // Those two categories may overlap: if a node moved from a position to another, it is reported as\n    // two mutation records, one with a \"removedNodes\" and the other with \"addedNodes\". In this case,\n    // the node will be in both sets.\n    var addedAndMovedNodes = new Set();\n    var removedNodes = new Map();\n    var _loop_1 = function (mutation) {\n        mutation.addedNodes.forEach(function (node) {\n            addedAndMovedNodes.add(node);\n        });\n        mutation.removedNodes.forEach(function (node) {\n            if (!addedAndMovedNodes.has(node)) {\n                removedNodes.set(node, mutation.target);\n            }\n            addedAndMovedNodes.delete(node);\n        });\n    };\n    for (var _i = 0, mutations_1 = mutations; _i < mutations_1.length; _i++) {\n        var mutation = mutations_1[_i];\n        _loop_1(mutation);\n    }\n    // Then, we sort nodes that are still in the document by topological order, for two reasons:\n    //\n    // * We will serialize each added nodes with their descendants. We don't want to serialize a node\n    // twice, so we need to iterate over the parent nodes first and skip any node that is contained in\n    // a precedent node.\n    //\n    // * To emit \"add\" mutations, we need references to the parent and potential next sibling of each\n    // added node. So we need to iterate over the parent nodes first, and when multiple nodes are\n    // siblings, we want to iterate from last to first. This will ensure that any \"next\" node is\n    // already serialized and have an id.\n    var sortedAddedAndMovedNodes = Array.from(addedAndMovedNodes);\n    sortAddedAndMovedNodes(sortedAddedAndMovedNodes);\n    // Then, we iterate over our sorted node sets to emit mutations. We collect the newly serialized\n    // node ids in a set to be able to skip subsequent related mutations.\n    var serializedNodeIds = new Set();\n    var addedNodeMutations = [];\n    for (var _a = 0, sortedAddedAndMovedNodes_1 = sortedAddedAndMovedNodes; _a < sortedAddedAndMovedNodes_1.length; _a++) {\n        var node = sortedAddedAndMovedNodes_1[_a];\n        if (hasBeenSerialized(node)) {\n            continue;\n        }\n        var parentNodePrivacyLevel = getNodePrivacyLevel(node.parentNode, configuration.defaultPrivacyLevel);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        var serializedNode = serializeNodeWithId(node, {\n            serializedNodeIds: serializedNodeIds,\n            parentNodePrivacyLevel: parentNodePrivacyLevel,\n            serializationContext: { status: 2 /* MUTATION */, shadowRootsController: shadowRootsController },\n            configuration: configuration,\n        });\n        if (!serializedNode) {\n            continue;\n        }\n        var parentNode = getParentNode(node);\n        addedNodeMutations.push({\n            nextId: getNextSibling(node),\n            parentId: getSerializedNodeId(parentNode),\n            node: serializedNode,\n        });\n    }\n    // Finally, we emit remove mutations.\n    var removedNodeMutations = [];\n    removedNodes.forEach(function (parent, node) {\n        if (hasSerializedNode(node)) {\n            removedNodeMutations.push({\n                parentId: getSerializedNodeId(parent),\n                id: getSerializedNodeId(node),\n            });\n        }\n    });\n    return { adds: addedNodeMutations, removes: removedNodeMutations, hasBeenSerialized: hasBeenSerialized };\n    function hasBeenSerialized(node) {\n        return hasSerializedNode(node) && serializedNodeIds.has(getSerializedNodeId(node));\n    }\n    function getNextSibling(node) {\n        var nextSibling = node.nextSibling;\n        while (nextSibling) {\n            if (hasSerializedNode(nextSibling)) {\n                return getSerializedNodeId(nextSibling);\n            }\n            nextSibling = nextSibling.nextSibling;\n        }\n        return null;\n    }\n}\nfunction processCharacterDataMutations(mutations, configuration) {\n    var _a;\n    var textMutations = [];\n    // Deduplicate mutations based on their target node\n    var handledNodes = new Set();\n    var filteredMutations = mutations.filter(function (mutation) {\n        if (handledNodes.has(mutation.target)) {\n            return false;\n        }\n        handledNodes.add(mutation.target);\n        return true;\n    });\n    // Emit mutations\n    for (var _i = 0, filteredMutations_1 = filteredMutations; _i < filteredMutations_1.length; _i++) {\n        var mutation = filteredMutations_1[_i];\n        var value = mutation.target.textContent;\n        if (value === mutation.oldValue) {\n            continue;\n        }\n        var parentNodePrivacyLevel = getNodePrivacyLevel(getParentNode(mutation.target), configuration.defaultPrivacyLevel);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        textMutations.push({\n            id: getSerializedNodeId(mutation.target),\n            // TODO: pass a valid \"ignoreWhiteSpace\" argument\n            value: (_a = getTextContent(mutation.target, false, parentNodePrivacyLevel)) !== null && _a !== void 0 ? _a : null,\n        });\n    }\n    return textMutations;\n}\nfunction processAttributesMutations(mutations, configuration) {\n    var attributeMutations = [];\n    // Deduplicate mutations based on their target node and changed attribute\n    var handledElements = new Map();\n    var filteredMutations = mutations.filter(function (mutation) {\n        var handledAttributes = handledElements.get(mutation.target);\n        if (handledAttributes === null || handledAttributes === void 0 ? void 0 : handledAttributes.has(mutation.attributeName)) {\n            return false;\n        }\n        if (!handledAttributes) {\n            handledElements.set(mutation.target, new Set([mutation.attributeName]));\n        }\n        else {\n            handledAttributes.add(mutation.attributeName);\n        }\n        return true;\n    });\n    // Emit mutations\n    var emittedMutations = new Map();\n    for (var _i = 0, filteredMutations_2 = filteredMutations; _i < filteredMutations_2.length; _i++) {\n        var mutation = filteredMutations_2[_i];\n        var uncensoredValue = mutation.target.getAttribute(mutation.attributeName);\n        if (uncensoredValue === mutation.oldValue) {\n            continue;\n        }\n        var privacyLevel = getNodePrivacyLevel(mutation.target, configuration.defaultPrivacyLevel);\n        var attributeValue = serializeAttribute(mutation.target, privacyLevel, mutation.attributeName, configuration);\n        var transformedValue = void 0;\n        if (mutation.attributeName === 'value') {\n            var inputValue = getElementInputValue(mutation.target, privacyLevel);\n            if (inputValue === undefined) {\n                continue;\n            }\n            transformedValue = inputValue;\n        }\n        else if (typeof attributeValue === 'string') {\n            transformedValue = attributeValue;\n        }\n        else {\n            transformedValue = null;\n        }\n        var emittedMutation = emittedMutations.get(mutation.target);\n        if (!emittedMutation) {\n            emittedMutation = {\n                id: getSerializedNodeId(mutation.target),\n                attributes: {},\n            };\n            attributeMutations.push(emittedMutation);\n            emittedMutations.set(mutation.target, emittedMutation);\n        }\n        emittedMutation.attributes[mutation.attributeName] = transformedValue;\n    }\n    return attributeMutations;\n}\nexport function sortAddedAndMovedNodes(nodes) {\n    nodes.sort(function (a, b) {\n        var position = a.compareDocumentPosition(b);\n        /* eslint-disable no-bitwise */\n        if (position & Node.DOCUMENT_POSITION_CONTAINED_BY) {\n            return -1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_CONTAINS) {\n            return 1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_FOLLOWING) {\n            return 1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_PRECEDING) {\n            return -1;\n        }\n        /* eslint-enable no-bitwise */\n        return 0;\n    });\n}\nfunction traverseRemovedShadowDom(removedNode, shadowDomRemovedCallback) {\n    if (isNodeShadowHost(removedNode)) {\n        shadowDomRemovedCallback(removedNode.shadowRoot);\n    }\n    getChildNodes(removedNode).forEach(function (child) { return traverseRemovedShadowDom(child, shadowDomRemovedCallback); });\n}\n//# sourceMappingURL=mutationObserver.js.map","/**\n * Browsers have not standardized various dimension properties. Mobile devices typically report\n * dimensions in reference to the visual viewport, while desktop uses the layout viewport. For example,\n * Mobile Chrome will change innerWidth when a pinch zoom takes place, while Chrome Desktop (mac) will not.\n *\n * With the new Viewport API, we now calculate and normalize dimension properties to the layout viewport.\n * If the VisualViewport API is not supported by a browser, it isn't reasonably possible to detect or normalize\n * which viewport is being measured. Therefore these exported functions will fallback to assuming that the layout\n * viewport is being measured by the browser\n */\n// Scrollbar widths vary across properties on different devices and browsers\nvar TOLERANCE = 25;\n/**\n * Use the Visual Viewport API's properties to measure scrollX/Y in reference to the layout viewport\n * in order to determine if window.scrollX/Y is measuring the layout or visual viewport.\n * This finding corresponds to which viewport mouseEvent.clientX/Y and window.innerWidth/Height measures.\n */\nfunction isVisualViewportFactoredIn() {\n    var visual = window.visualViewport;\n    return (Math.abs(visual.pageTop - visual.offsetTop - window.scrollY) > TOLERANCE ||\n        Math.abs(visual.pageLeft - visual.offsetLeft - window.scrollX) > TOLERANCE);\n}\nexport var convertMouseEventToLayoutCoordinates = function (clientX, clientY) {\n    var visual = window.visualViewport;\n    var normalised = {\n        layoutViewportX: clientX,\n        layoutViewportY: clientY,\n        visualViewportX: clientX,\n        visualViewportY: clientY,\n    };\n    if (!visual) {\n        // On old browsers, we cannot normalise, so fallback to clientX/Y\n        return normalised;\n    }\n    else if (isVisualViewportFactoredIn()) {\n        // Typically Mobile Devices\n        normalised.layoutViewportX = Math.round(clientX + visual.offsetLeft);\n        normalised.layoutViewportY = Math.round(clientY + visual.offsetTop);\n    }\n    else {\n        // Typically Desktop Devices\n        normalised.visualViewportX = Math.round(clientX - visual.offsetLeft);\n        normalised.visualViewportY = Math.round(clientY - visual.offsetTop);\n    }\n    return normalised;\n};\nexport var getVisualViewport = function () {\n    var visual = window.visualViewport;\n    return {\n        scale: visual.scale,\n        offsetLeft: visual.offsetLeft,\n        offsetTop: visual.offsetTop,\n        pageLeft: visual.pageLeft,\n        pageTop: visual.pageTop,\n        height: visual.height,\n        width: visual.width,\n    };\n};\nexport function getScrollX() {\n    var scrollX;\n    var visual = window.visualViewport;\n    if (visual) {\n        scrollX = visual.pageLeft - visual.offsetLeft;\n    }\n    else if (window.scrollX !== undefined) {\n        scrollX = window.scrollX;\n    }\n    else {\n        scrollX = window.pageXOffset || 0;\n    }\n    return Math.round(scrollX);\n}\nexport function getScrollY() {\n    var scrollY;\n    var visual = window.visualViewport;\n    if (visual) {\n        scrollY = visual.pageTop - visual.offsetTop;\n    }\n    else if (window.scrollY !== undefined) {\n        scrollY = window.scrollY;\n    }\n    else {\n        scrollY = window.pageYOffset || 0;\n    }\n    return Math.round(scrollY);\n}\n//# sourceMappingURL=viewports.js.map","var _a;\nimport { instrumentSetter, instrumentMethodAndCallOriginal, assign, throttle, addEventListeners, addEventListener, noop, addTelemetryDebug, } from '@datadog/browser-core';\nimport { isNodeShadowHost, initViewportObservable, } from '@datadog/browser-rum-core';\nimport { NodePrivacyLevel } from '../../constants';\nimport { RecordType, IncrementalSource, MediaInteractionType, MouseInteractionType } from '../../types';\nimport { getNodePrivacyLevel, shouldMaskNode } from './privacy';\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode } from './serializationUtils';\nimport { assembleIncrementalSnapshot, forEach, getPathToNestedCSSRule, isTouchEvent } from './utils';\nimport { startMutationObserver } from './mutationObserver';\nimport { getVisualViewport, getScrollX, getScrollY, convertMouseEventToLayoutCoordinates } from './viewports';\nvar MOUSE_MOVE_OBSERVER_THRESHOLD = 50;\nvar SCROLL_OBSERVER_THRESHOLD = 100;\nvar VISUAL_VIEWPORT_OBSERVER_THRESHOLD = 200;\nvar recordIds = new WeakMap();\nvar nextId = 1;\nexport function getRecordIdForEvent(event) {\n    if (!recordIds.has(event)) {\n        recordIds.set(event, nextId++);\n    }\n    return recordIds.get(event);\n}\nexport function initObservers(o) {\n    var mutationHandler = initMutationObserver(o.mutationCb, o.configuration, o.shadowRootsController);\n    var mousemoveHandler = initMoveObserver(o.mousemoveCb);\n    var mouseInteractionHandler = initMouseInteractionObserver(o.mouseInteractionCb, o.configuration.defaultPrivacyLevel);\n    var scrollHandler = initScrollObserver(o.scrollCb, o.configuration.defaultPrivacyLevel, o.elementsScrollPositions);\n    var viewportResizeHandler = initViewportResizeObserver(o.viewportResizeCb);\n    var inputHandler = initInputObserver(o.inputCb, o.configuration.defaultPrivacyLevel);\n    var mediaInteractionHandler = initMediaInteractionObserver(o.mediaInteractionCb, o.configuration.defaultPrivacyLevel);\n    var styleSheetObserver = initStyleSheetObserver(o.styleSheetCb);\n    var focusHandler = initFocusObserver(o.focusCb);\n    var visualViewportResizeHandler = initVisualViewportResizeObserver(o.visualViewportResizeCb);\n    var frustrationHandler = initFrustrationObserver(o.lifeCycle, o.frustrationCb);\n    return {\n        flush: function () {\n            mutationHandler.flush();\n        },\n        stop: function () {\n            mutationHandler.stop();\n            mousemoveHandler();\n            mouseInteractionHandler();\n            scrollHandler();\n            viewportResizeHandler();\n            inputHandler();\n            mediaInteractionHandler();\n            styleSheetObserver();\n            focusHandler();\n            visualViewportResizeHandler();\n            frustrationHandler();\n        },\n    };\n}\nexport function initMutationObserver(cb, configuration, shadowRootsController) {\n    return startMutationObserver(cb, configuration, shadowRootsController, document);\n}\nexport function initMoveObserver(cb) {\n    var updatePosition = throttle(function (event) {\n        var target = getEventTarget(event);\n        if (hasSerializedNode(target)) {\n            var coordinates = tryToComputeCoordinates(event);\n            if (!coordinates) {\n                return;\n            }\n            var position = {\n                id: getSerializedNodeId(target),\n                timeOffset: 0,\n                x: coordinates.x,\n                y: coordinates.y,\n            };\n            cb([position], isTouchEvent(event) ? IncrementalSource.TouchMove : IncrementalSource.MouseMove);\n        }\n    }, MOUSE_MOVE_OBSERVER_THRESHOLD, {\n        trailing: false,\n    }).throttled;\n    return addEventListeners(document, [\"mousemove\" /* MOUSE_MOVE */, \"touchmove\" /* TOUCH_MOVE */], updatePosition, {\n        capture: true,\n        passive: true,\n    }).stop;\n}\nvar eventTypeToMouseInteraction = (_a = {},\n    // Listen for pointerup DOM events instead of mouseup for MouseInteraction/MouseUp records. This\n    // allows to reference such records from Frustration records.\n    //\n    // In the context of supporting Mobile Session Replay, we introduced `PointerInteraction` records\n    // used by the Mobile SDKs in place of `MouseInteraction`. In the future, we should replace\n    // `MouseInteraction` by `PointerInteraction` in the Browser SDK so we have an uniform way to\n    // convey such interaction. This would cleanly solve the issue since we would have\n    // `PointerInteraction/Up` records that we could reference from `Frustration` records.\n    _a[\"pointerup\" /* POINTER_UP */] = MouseInteractionType.MouseUp,\n    _a[\"mousedown\" /* MOUSE_DOWN */] = MouseInteractionType.MouseDown,\n    _a[\"click\" /* CLICK */] = MouseInteractionType.Click,\n    _a[\"contextmenu\" /* CONTEXT_MENU */] = MouseInteractionType.ContextMenu,\n    _a[\"dblclick\" /* DBL_CLICK */] = MouseInteractionType.DblClick,\n    _a[\"focus\" /* FOCUS */] = MouseInteractionType.Focus,\n    _a[\"blur\" /* BLUR */] = MouseInteractionType.Blur,\n    _a[\"touchstart\" /* TOUCH_START */] = MouseInteractionType.TouchStart,\n    _a[\"touchend\" /* TOUCH_END */] = MouseInteractionType.TouchEnd,\n    _a);\nexport function initMouseInteractionObserver(cb, defaultPrivacyLevel) {\n    var handler = function (event) {\n        var target = getEventTarget(event);\n        if (getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN || !hasSerializedNode(target)) {\n            return;\n        }\n        var id = getSerializedNodeId(target);\n        var type = eventTypeToMouseInteraction[event.type];\n        var interaction;\n        if (type !== MouseInteractionType.Blur && type !== MouseInteractionType.Focus) {\n            var coordinates = tryToComputeCoordinates(event);\n            if (!coordinates) {\n                return;\n            }\n            interaction = { id: id, type: type, x: coordinates.x, y: coordinates.y };\n        }\n        else {\n            interaction = { id: id, type: type };\n        }\n        var record = assign({ id: getRecordIdForEvent(event) }, assembleIncrementalSnapshot(IncrementalSource.MouseInteraction, interaction));\n        cb(record);\n    };\n    return addEventListeners(document, Object.keys(eventTypeToMouseInteraction), handler, {\n        capture: true,\n        passive: true,\n    }).stop;\n}\nfunction tryToComputeCoordinates(event) {\n    var _a = isTouchEvent(event) ? event.changedTouches[0] : event, x = _a.clientX, y = _a.clientY;\n    if (window.visualViewport) {\n        var _b = convertMouseEventToLayoutCoordinates(x, y), visualViewportX = _b.visualViewportX, visualViewportY = _b.visualViewportY;\n        x = visualViewportX;\n        y = visualViewportY;\n    }\n    if (!Number.isFinite(x) || !Number.isFinite(y)) {\n        if (event.isTrusted) {\n            addTelemetryDebug('mouse/touch event without x/y');\n        }\n        return undefined;\n    }\n    return { x: x, y: y };\n}\nfunction initScrollObserver(cb, defaultPrivacyLevel, elementsScrollPositions) {\n    var updatePosition = throttle(function (event) {\n        var target = getEventTarget(event);\n        if (!target ||\n            getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        var id = getSerializedNodeId(target);\n        var scrollPositions = target === document\n            ? {\n                scrollTop: getScrollY(),\n                scrollLeft: getScrollX(),\n            }\n            : {\n                scrollTop: Math.round(target.scrollTop),\n                scrollLeft: Math.round(target.scrollLeft),\n            };\n        elementsScrollPositions.set(target, scrollPositions);\n        cb({\n            id: id,\n            x: scrollPositions.scrollLeft,\n            y: scrollPositions.scrollTop,\n        });\n    }, SCROLL_OBSERVER_THRESHOLD).throttled;\n    return addEventListener(document, \"scroll\" /* SCROLL */, updatePosition, { capture: true, passive: true }).stop;\n}\nfunction initViewportResizeObserver(cb) {\n    return initViewportObservable().subscribe(cb).unsubscribe;\n}\nexport function initInputObserver(cb, defaultPrivacyLevel, _a) {\n    var _b = _a === void 0 ? {} : _a, _c = _b.domEvents, domEvents = _c === void 0 ? [\"input\" /* INPUT */, \"change\" /* CHANGE */] : _c, _d = _b.target, target = _d === void 0 ? document : _d;\n    var lastInputStateMap = new WeakMap();\n    function onElementChange(target) {\n        var nodePrivacyLevel = getNodePrivacyLevel(target, defaultPrivacyLevel);\n        if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n            return;\n        }\n        var type = target.type;\n        var inputState;\n        if (type === 'radio' || type === 'checkbox') {\n            if (shouldMaskNode(target, nodePrivacyLevel)) {\n                return;\n            }\n            inputState = { isChecked: target.checked };\n        }\n        else {\n            var value = getElementInputValue(target, nodePrivacyLevel);\n            if (value === undefined) {\n                return;\n            }\n            inputState = { text: value };\n        }\n        // Can be multiple changes on the same node within the same batched mutation observation.\n        cbWithDedup(target, inputState);\n        // If a radio was checked, other radios with the same name attribute will be unchecked.\n        var name = target.name;\n        if (type === 'radio' && name && target.checked) {\n            forEach(document.querySelectorAll(\"input[type=\\\"radio\\\"][name=\\\"\".concat(name, \"\\\"]\")), function (el) {\n                if (el !== target) {\n                    // TODO: Consider the privacy implications for various differing input privacy levels\n                    cbWithDedup(el, { isChecked: false });\n                }\n            });\n        }\n    }\n    /**\n     * There can be multiple changes on the same node within the same batched mutation observation.\n     */\n    function cbWithDedup(target, inputState) {\n        if (!hasSerializedNode(target)) {\n            return;\n        }\n        var lastInputState = lastInputStateMap.get(target);\n        if (!lastInputState ||\n            lastInputState.text !== inputState.text ||\n            lastInputState.isChecked !== inputState.isChecked) {\n            lastInputStateMap.set(target, inputState);\n            cb(assign({\n                id: getSerializedNodeId(target),\n            }, inputState));\n        }\n    }\n    var stopEventListeners = addEventListeners(target, domEvents, function (event) {\n        var target = getEventTarget(event);\n        if (target instanceof HTMLInputElement ||\n            target instanceof HTMLTextAreaElement ||\n            target instanceof HTMLSelectElement) {\n            onElementChange(target);\n        }\n    }, {\n        capture: true,\n        passive: true,\n    }).stop;\n    var instrumentationStoppers = [\n        instrumentSetter(HTMLInputElement.prototype, 'value', onElementChange),\n        instrumentSetter(HTMLInputElement.prototype, 'checked', onElementChange),\n        instrumentSetter(HTMLSelectElement.prototype, 'value', onElementChange),\n        instrumentSetter(HTMLTextAreaElement.prototype, 'value', onElementChange),\n        instrumentSetter(HTMLSelectElement.prototype, 'selectedIndex', onElementChange),\n    ];\n    return function () {\n        instrumentationStoppers.forEach(function (stopper) { return stopper.stop(); });\n        stopEventListeners();\n    };\n}\nexport function initStyleSheetObserver(cb) {\n    function checkStyleSheetAndCallback(styleSheet, callback) {\n        if (styleSheet && hasSerializedNode(styleSheet.ownerNode)) {\n            callback(getSerializedNodeId(styleSheet.ownerNode));\n        }\n    }\n    var instrumentationStoppers = [\n        instrumentMethodAndCallOriginal(CSSStyleSheet.prototype, 'insertRule', {\n            before: function (rule, index) {\n                checkStyleSheetAndCallback(this, function (id) { return cb({ id: id, adds: [{ rule: rule, index: index }] }); });\n            },\n        }),\n        instrumentMethodAndCallOriginal(CSSStyleSheet.prototype, 'deleteRule', {\n            before: function (index) {\n                checkStyleSheetAndCallback(this, function (id) { return cb({ id: id, removes: [{ index: index }] }); });\n            },\n        }),\n    ];\n    if (typeof CSSGroupingRule !== 'undefined') {\n        instrumentGroupingCSSRuleClass(CSSGroupingRule);\n    }\n    else {\n        instrumentGroupingCSSRuleClass(CSSMediaRule);\n        instrumentGroupingCSSRuleClass(CSSSupportsRule);\n    }\n    function instrumentGroupingCSSRuleClass(cls) {\n        instrumentationStoppers.push(instrumentMethodAndCallOriginal(cls.prototype, 'insertRule', {\n            before: function (rule, index) {\n                var _this = this;\n                checkStyleSheetAndCallback(this.parentStyleSheet, function (id) {\n                    var path = getPathToNestedCSSRule(_this);\n                    if (path) {\n                        path.push(index || 0);\n                        cb({ id: id, adds: [{ rule: rule, index: path }] });\n                    }\n                });\n            },\n        }), instrumentMethodAndCallOriginal(cls.prototype, 'deleteRule', {\n            before: function (index) {\n                var _this = this;\n                checkStyleSheetAndCallback(this.parentStyleSheet, function (id) {\n                    var path = getPathToNestedCSSRule(_this);\n                    if (path) {\n                        path.push(index);\n                        cb({ id: id, removes: [{ index: path }] });\n                    }\n                });\n            },\n        }));\n    }\n    return function () { return instrumentationStoppers.forEach(function (stopper) { return stopper.stop(); }); };\n}\nfunction initMediaInteractionObserver(mediaInteractionCb, defaultPrivacyLevel) {\n    var handler = function (event) {\n        var target = getEventTarget(event);\n        if (!target ||\n            getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        mediaInteractionCb({\n            id: getSerializedNodeId(target),\n            type: event.type === \"play\" /* PLAY */ ? MediaInteractionType.Play : MediaInteractionType.Pause,\n        });\n    };\n    return addEventListeners(document, [\"play\" /* PLAY */, \"pause\" /* PAUSE */], handler, { capture: true, passive: true }).stop;\n}\nfunction initFocusObserver(focusCb) {\n    return addEventListeners(window, [\"focus\" /* FOCUS */, \"blur\" /* BLUR */], function () {\n        focusCb({ has_focus: document.hasFocus() });\n    }).stop;\n}\nfunction initVisualViewportResizeObserver(cb) {\n    if (!window.visualViewport) {\n        return noop;\n    }\n    var _a = throttle(function () {\n        cb(getVisualViewport());\n    }, VISUAL_VIEWPORT_OBSERVER_THRESHOLD, {\n        trailing: false,\n    }), updateDimension = _a.throttled, cancelThrottle = _a.cancel;\n    var removeListener = addEventListeners(window.visualViewport, [\"resize\" /* RESIZE */, \"scroll\" /* SCROLL */], updateDimension, {\n        capture: true,\n        passive: true,\n    }).stop;\n    return function stop() {\n        removeListener();\n        cancelThrottle();\n    };\n}\nexport function initFrustrationObserver(lifeCycle, frustrationCb) {\n    return lifeCycle.subscribe(10 /* RAW_RUM_EVENT_COLLECTED */, function (data) {\n        var _a, _b, _c;\n        if (data.rawRumEvent.type === \"action\" /* ACTION */ &&\n            data.rawRumEvent.action.type === \"click\" /* CLICK */ &&\n            ((_b = (_a = data.rawRumEvent.action.frustration) === null || _a === void 0 ? void 0 : _a.type) === null || _b === void 0 ? void 0 : _b.length) &&\n            'events' in data.domainContext &&\n            ((_c = data.domainContext.events) === null || _c === void 0 ? void 0 : _c.length)) {\n            frustrationCb({\n                timestamp: data.rawRumEvent.date,\n                type: RecordType.FrustrationRecord,\n                data: {\n                    frustrationTypes: data.rawRumEvent.action.frustration.type,\n                    recordIds: data.domainContext.events.map(function (e) { return getRecordIdForEvent(e); }),\n                },\n            });\n        }\n    }).unsubscribe;\n}\nfunction getEventTarget(event) {\n    if (event.composed === true && isNodeShadowHost(event.target)) {\n        return event.composedPath()[0];\n    }\n    return event.target;\n}\n//# sourceMappingURL=observers.js.map","import { addTelemetryDebug, isExperimentalFeatureEnabled } from '@datadog/browser-core';\nimport { startMutationObserver } from './mutationObserver';\nimport { initInputObserver } from './observers';\nexport var initShadowRootsController = function (configuration, _a) {\n    var mutationCb = _a.mutationCb, inputCb = _a.inputCb;\n    var controllerByShadowRoot = new Map();\n    var shadowRootsController = {\n        addShadowRoot: function (shadowRoot) {\n            var _a = startMutationObserver(mutationCb, configuration, shadowRootsController, shadowRoot), stopMutationObserver = _a.stop, flush = _a.flush;\n            // the change event no do bubble up across the shadow root, we have to listen on the shadow root\n            var stopInputObserver = initInputObserver(inputCb, configuration.defaultPrivacyLevel, {\n                target: shadowRoot,\n                domEvents: [\"change\" /* CHANGE */],\n            });\n            controllerByShadowRoot.set(shadowRoot, {\n                flush: flush,\n                stop: function () {\n                    stopMutationObserver();\n                    stopInputObserver();\n                },\n            });\n        },\n        removeShadowRoot: function (shadowRoot) {\n            var entry = controllerByShadowRoot.get(shadowRoot);\n            if (!entry) {\n                addTelemetryDebug('no shadow root in map', {\n                    shadowRoot: shadowRoot ? shadowRoot.nodeName : 'no node name',\n                    childrenLength: shadowRoot ? shadowRoot.childElementCount : '-1',\n                    controllerByShadowRootSize: controllerByShadowRoot.size,\n                    html: shadowRoot && isExperimentalFeatureEnabled('shadow_dom_debug')\n                        ? shadowRoot.innerHTML.substring(0, 2000)\n                        : undefined,\n                });\n                return;\n            }\n            entry.stop();\n            controllerByShadowRoot.delete(shadowRoot);\n        },\n        stop: function () {\n            controllerByShadowRoot.forEach(function (_a) {\n                var stop = _a.stop;\n                return stop();\n            });\n        },\n        flush: function () {\n            controllerByShadowRoot.forEach(function (_a) {\n                var flush = _a.flush;\n                return flush();\n            });\n        },\n    };\n    return shadowRootsController;\n};\n//# sourceMappingURL=shadowRootsController.js.map","import { timeStampNow } from '@datadog/browser-core';\nimport { getViewportDimension } from '@datadog/browser-rum-core';\nimport { RecordType, IncrementalSource } from '../../types';\nimport { serializeDocument } from './serialize';\nimport { initObservers } from './observers';\nimport { getVisualViewport, getScrollX, getScrollY } from './viewports';\nimport { assembleIncrementalSnapshot } from './utils';\nimport { createElementsScrollPositions } from './elementsScrollPositions';\nimport { initShadowRootsController } from './shadowRootsController';\nexport function record(options) {\n    var emit = options.emit;\n    // runtime checks for user options\n    if (!emit) {\n        throw new Error('emit function is required');\n    }\n    var elementsScrollPositions = createElementsScrollPositions();\n    var mutationCb = function (mutation) {\n        emit(assembleIncrementalSnapshot(IncrementalSource.Mutation, mutation));\n    };\n    var inputCb = function (s) { return emit(assembleIncrementalSnapshot(IncrementalSource.Input, s)); };\n    var shadowRootsController = initShadowRootsController(options.configuration, { mutationCb: mutationCb, inputCb: inputCb });\n    var takeFullSnapshot = function (timestamp, serializationContext) {\n        if (timestamp === void 0) { timestamp = timeStampNow(); }\n        if (serializationContext === void 0) { serializationContext = {\n            status: 0 /* INITIAL_FULL_SNAPSHOT */,\n            elementsScrollPositions: elementsScrollPositions,\n            shadowRootsController: shadowRootsController,\n        }; }\n        var _a = getViewportDimension(), width = _a.width, height = _a.height;\n        emit({\n            data: {\n                height: height,\n                href: window.location.href,\n                width: width,\n            },\n            type: RecordType.Meta,\n            timestamp: timestamp,\n        });\n        emit({\n            data: {\n                has_focus: document.hasFocus(),\n            },\n            type: RecordType.Focus,\n            timestamp: timestamp,\n        });\n        emit({\n            data: {\n                node: serializeDocument(document, options.configuration, serializationContext),\n                initialOffset: {\n                    left: getScrollX(),\n                    top: getScrollY(),\n                },\n            },\n            type: RecordType.FullSnapshot,\n            timestamp: timestamp,\n        });\n        if (window.visualViewport) {\n            emit({\n                data: getVisualViewport(),\n                type: RecordType.VisualViewport,\n                timestamp: timestamp,\n            });\n        }\n    };\n    takeFullSnapshot();\n    var _a = initObservers({\n        lifeCycle: options.lifeCycle,\n        configuration: options.configuration,\n        elementsScrollPositions: elementsScrollPositions,\n        inputCb: inputCb,\n        mediaInteractionCb: function (p) {\n            return emit(assembleIncrementalSnapshot(IncrementalSource.MediaInteraction, p));\n        },\n        mouseInteractionCb: function (mouseInteractionRecord) { return emit(mouseInteractionRecord); },\n        mousemoveCb: function (positions, source) { return emit(assembleIncrementalSnapshot(source, { positions: positions })); },\n        mutationCb: mutationCb,\n        scrollCb: function (p) { return emit(assembleIncrementalSnapshot(IncrementalSource.Scroll, p)); },\n        styleSheetCb: function (r) { return emit(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, r)); },\n        viewportResizeCb: function (d) { return emit(assembleIncrementalSnapshot(IncrementalSource.ViewportResize, d)); },\n        frustrationCb: function (frustrationRecord) { return emit(frustrationRecord); },\n        focusCb: function (data) {\n            return emit({\n                data: data,\n                type: RecordType.Focus,\n                timestamp: timeStampNow(),\n            });\n        },\n        visualViewportResizeCb: function (data) {\n            emit({\n                data: data,\n                type: RecordType.VisualViewport,\n                timestamp: timeStampNow(),\n            });\n        },\n        shadowRootsController: shadowRootsController,\n    }), stopObservers = _a.stop, flushMutationsFromObservers = _a.flush;\n    function flushMutations() {\n        shadowRootsController.flush();\n        flushMutationsFromObservers();\n    }\n    return {\n        stop: function () {\n            shadowRootsController.stop();\n            stopObservers();\n        },\n        takeSubsequentFullSnapshot: function (timestamp) {\n            flushMutations();\n            takeFullSnapshot(timestamp, {\n                shadowRootsController: shadowRootsController,\n                status: 1 /* SUBSEQUENT_FULL_SNAPSHOT */,\n                elementsScrollPositions: elementsScrollPositions,\n            });\n        },\n        flushMutations: flushMutations,\n        shadowRootsController: shadowRootsController,\n    };\n}\n//# sourceMappingURL=record.js.map","export function createElementsScrollPositions() {\n    var scrollPositionsByElement = new WeakMap();\n    return {\n        set: function (element, scrollPositions) {\n            if (element === document && !document.scrollingElement) {\n                // cf https://drafts.csswg.org/cssom-view/#dom-document-scrollingelement,\n                // in some cases scrolling elements can not be defined, we don't support those for now\n                return;\n            }\n            scrollPositionsByElement.set(element === document ? document.scrollingElement : element, scrollPositions);\n        },\n        get: function (element) {\n            return scrollPositionsByElement.get(element);\n        },\n        has: function (element) {\n            return scrollPositionsByElement.has(element);\n        },\n    };\n}\n//# sourceMappingURL=elementsScrollPositions.js.map","import { timeStampNow, createHttpRequest } from '@datadog/browser-core';\nimport { record } from '../domain/record';\nimport { startSegmentCollection, SEGMENT_BYTES_LIMIT } from '../domain/segmentCollection';\nimport { RecordType } from '../types';\nexport function startRecording(lifeCycle, configuration, sessionManager, viewContexts, worker, httpRequest) {\n    var reportError = function (error) {\n        lifeCycle.notify(12 /* RAW_ERROR_COLLECTED */, { error: error });\n    };\n    var replayRequest = httpRequest || createHttpRequest(configuration.sessionReplayEndpointBuilder, SEGMENT_BYTES_LIMIT, reportError);\n    var _a = startSegmentCollection(lifeCycle, configuration.applicationId, sessionManager, viewContexts, replayRequest, worker), addRecord = _a.addRecord, stopSegmentCollection = _a.stop;\n    var _b = record({\n        emit: addRecord,\n        configuration: configuration,\n        lifeCycle: lifeCycle,\n    }), stopRecording = _b.stop, takeSubsequentFullSnapshot = _b.takeSubsequentFullSnapshot, flushMutations = _b.flushMutations;\n    var unsubscribeViewEnded = lifeCycle.subscribe(4 /* VIEW_ENDED */, function () {\n        flushMutations();\n        addRecord({\n            timestamp: timeStampNow(),\n            type: RecordType.ViewEnd,\n        });\n    }).unsubscribe;\n    var unsubscribeViewCreated = lifeCycle.subscribe(2 /* VIEW_CREATED */, function (view) {\n        takeSubsequentFullSnapshot(view.startClocks.timeStamp);\n    }).unsubscribe;\n    return {\n        stop: function () {\n            unsubscribeViewEnded();\n            unsubscribeViewCreated();\n            stopRecording();\n            stopSegmentCollection();\n        },\n    };\n}\n//# sourceMappingURL=startRecording.js.map","export var MAX_STATS_HISTORY = 10;\nvar statsPerView;\nexport function getSegmentsCount(viewId) {\n    return getOrCreateReplayStats(viewId).segments_count;\n}\nexport function addSegment(viewId) {\n    getOrCreateReplayStats(viewId).segments_count += 1;\n}\nexport function addRecord(viewId) {\n    getOrCreateReplayStats(viewId).records_count += 1;\n}\nexport function addWroteData(viewId, additionalBytesCount) {\n    getOrCreateReplayStats(viewId).segments_total_raw_size += additionalBytesCount;\n}\nexport function getReplayStats(viewId) {\n    return statsPerView === null || statsPerView === void 0 ? void 0 : statsPerView.get(viewId);\n}\nexport function resetReplayStats() {\n    statsPerView = undefined;\n}\nfunction getOrCreateReplayStats(viewId) {\n    if (!statsPerView) {\n        statsPerView = new Map();\n    }\n    var replayStats;\n    if (statsPerView.has(viewId)) {\n        replayStats = statsPerView.get(viewId);\n    }\n    else {\n        replayStats = {\n            records_count: 0,\n            segments_count: 0,\n            segments_total_raw_size: 0,\n        };\n        statsPerView.set(viewId, replayStats);\n        if (statsPerView.size > MAX_STATS_HISTORY) {\n            deleteOldestStats();\n        }\n    }\n    return replayStats;\n}\nfunction deleteOldestStats() {\n    if (!statsPerView) {\n        return;\n    }\n    if (statsPerView.keys) {\n        statsPerView.delete(statsPerView.keys().next().value);\n    }\n    else {\n        // IE11 doesn't support map.keys\n        var isFirst_1 = true;\n        statsPerView.forEach(function (_value, key) {\n            if (isFirst_1) {\n                statsPerView.delete(key);\n                isFirst_1 = false;\n            }\n        });\n    }\n}\n//# sourceMappingURL=replayStats.js.map"],"names":["makeRecorderApi","startRecordingImpl","startDeflateWorkerImpl","Array","from","CSSSupportsRule","NodeList","prototype","start","stop","getReplayStats","onRumStart","isRecording","state","status","startStrategy","stopStrategy","lifeCycle","configuration","sessionManager","viewContexts","subscribe","session","findTrackedSession","sessionReplayAllowed","worker","stopRecording","NodePrivacyLevel","IGNORE","HIDDEN","ALLOW","MASK","MASK_USER_INPUT","PRIVACY_ATTR_NAME","PRIVACY_ATTR_VALUE_ALLOW","PRIVACY_ATTR_VALUE_MASK","PRIVACY_ATTR_VALUE_MASK_USER_INPUT","PRIVACY_ATTR_VALUE_HIDDEN","PRIVACY_CLASS_ALLOW","PRIVACY_CLASS_MASK","PRIVACY_CLASS_MASK_USER_INPUT","PRIVACY_CLASS_HIDDEN","CENSORED_STRING_MARK","CENSORED_IMG_MARK","FORM_PRIVATE_TAG_NAMES","INPUT","OUTPUT","TEXTAREA","SELECT","OPTION","DATALIST","OPTGROUP","MAX_ATTRIBUTE_VALUE_CHAR_LENGTH","getNodePrivacyLevel","node","defaultPrivacyLevel","parentNode","parentNodePrivacyLevel","reducePrivacyLevel","getNodeSelfPrivacyLevel","childPrivacyLevel","privAttr","getAttribute","tagName","inputElement","type","autocomplete","indexOf","classList","contains","element","nodeName","relAttribute","getLowerCaseAttribute","test","nameAttribute","propertyAttribute","hasAttribute","name","toLowerCase","shouldIgnoreElement","shouldMaskNode","privacyLevel","isFormElement","nodeType","ELEMENT_NODE","censorText","text","replace","getTextContent","textNode","ignoreWhiteSpace","_a","parentTagName","parentElement","textContent","trim","nodePrivacyLevel","isStyle","undefined","serializedNodeIds","WeakMap","hasSerializedNode","has","getSerializedNodeId","get","getElementInputValue","value","URL_IN_CSS_REF","ABSOLUTE_URL","DATA_URI","switchToAbsoluteUrl","cssText","cssHref","matchingSubstring","singleQuote","urlWrappedInSingleQuotes","doubleQuote","urlWrappedInDoubleQuotes","urlNotWrappedInQuotes","url","quote","concat","baseUrl","href","_","makeUrlAbsolute","serializeStyleSheets","cssStyleSheets","length","map","cssStyleSheet","rules","cssRules","cssRule","disabled","media","serializeDocument","document","serializationContext","serializeNodeWithId","options","serializedNode","DOCUMENT_NODE","childNodes","serializeChildNodes","adoptedStyleSheets","serializeDocumentNode","DOCUMENT_FRAGMENT_NODE","isShadowRoot","shadowRootsController","addShadowRoot","serializeDocumentFragmentNode","DOCUMENT_TYPE_NODE","documentType","publicId","systemId","getValidTagName","isSVG","el","SVGElement","_b","getBoundingClientRect","width","height","attributes","rr_width","rr_height","safeAttrs","doc","ownerDocument","i","attributeName","item","attributeValue","serializeAttribute","formValue","optionElement","selected","stylesheet","styleSheets","find","s","getCssRulesString","_cssText","sheet","innerText","scrollTop","scrollLeft","checked","mediaElement","rr_mediaState","paused","Math","round","elementsScrollPositions","set","rr_scrollLeft","rr_scrollTop","getAttributesForPrivacyLevel","shadowRoot","push","serializeElementNode","TEXT_NODE","serializeTextNode","CDATA_SECTION_NODE","serializeNode","id","_nextId","serializedNodeWithId","serializeNodeId","setSerializedNodeId","add","result","forEach","childNode","serializedChildNode","actionNameAttribute","slice","TAG_NAME_REGEX","processedTagName","getCssRuleString","join","rule","isCSSImportRule","styleSheet","isTouchEvent","event","Boolean","changedTouches","assembleIncrementalSnapshot","source","data","timestamp","getPathToNestedCSSRule","path","currentRule","parentRule","index_1","unshift","parentStyleSheet","index","MUTATION_PROCESS_MAX_DELAY","startMutationObserver","mutationCallback","target","MutationObserver","flush","mutationBatch","processMutationBatch","cancelScheduledFlush","pendingMutations","addMutations","mutations","timeout","apply","createMutationBatch","filter","mutation","removedNodes","removedNode","traverseRemovedShadowDom","removeShadowRoot","filteredMutations","current","nodeAndAncestorsHaveSerializedNode","addedAndMovedNodes","Set","Map","_loop_1","addedNodes","delete","_i","mutations_1","sortedAddedAndMovedNodes","nodes","sort","a","b","position","compareDocumentPosition","Node","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_CONTAINS","DOCUMENT_POSITION_FOLLOWING","DOCUMENT_POSITION_PRECEDING","addedNodeMutations","sortedAddedAndMovedNodes_1","hasBeenSerialized","nextId","getNextSibling","parentId","removedNodeMutations","parent","adds","removes","nextSibling","processChildListMutations","texts","textMutations","handledNodes","filteredMutations_1","oldValue","processCharacterDataMutations","attributeMutations","handledElements","handledAttributes","emittedMutations","filteredMutations_2","transformedValue","inputValue","emittedMutation","processAttributesMutations","processMutations","observer","takeRecords","monitor","observe","attributeOldValue","characterData","characterDataOldValue","childList","subtree","disconnect","shadowDomRemovedCallback","child","convertMouseEventToLayoutCoordinates","clientX","clientY","visual","window","visualViewport","normalised","layoutViewportX","layoutViewportY","visualViewportX","visualViewportY","abs","pageTop","offsetTop","scrollY","pageLeft","offsetLeft","scrollX","isVisualViewportFactoredIn","getVisualViewport","scale","getScrollX","pageXOffset","getScrollY","pageYOffset","MOUSE_MOVE_OBSERVER_THRESHOLD","SCROLL_OBSERVER_THRESHOLD","VISUAL_VIEWPORT_OBSERVER_THRESHOLD","recordIds","getRecordIdForEvent","initObservers","o","cb","updatePosition","mediaInteractionCb","handler","focusCb","frustrationCb","mutationHandler","initMutationObserver","mutationCb","mousemoveHandler","mousemoveCb","getEventTarget","coordinates","tryToComputeCoordinates","timeOffset","x","y","trailing","throttled","addEventListener","capture","passive","mouseInteractionHandler","interaction","eventTypeToMouseInteraction","record","Object","keys","initMouseInteractionObserver","mouseInteractionCb","scrollHandler","scrollPositions","initScrollObserver","scrollCb","viewportResizeHandler","unsubscribe","initViewportResizeObserver","viewportResizeCb","inputHandler","initInputObserver","inputCb","mediaInteractionHandler","styleSheetObserver","checkStyleSheetAndCallback","callback","ownerNode","instrumentationStoppers","instrumentMethod","CSSStyleSheet","before","this","CSSGroupingRule","instrumentGroupingCSSRuleClass","CSSMediaRule","cls","_this","stopper","initStyleSheetObserver","styleSheetCb","focusHandler","has_focus","hasFocus","visualViewportResizeHandler","updateDimension","cancelThrottle","cancel","removeListener","initVisualViewportResizeObserver","visualViewportResizeCb","frustrationHandler","_c","rawRumEvent","action","frustration","domainContext","events","date","frustrationTypes","e","Number","isFinite","isTrusted","domEvents","_d","lastInputStateMap","onElementChange","inputState","isChecked","cbWithDedup","list","querySelectorAll","call","lastInputState","stopEventListeners","HTMLInputElement","HTMLTextAreaElement","HTMLSelectElement","composed","composedPath","initShadowRootsController","controllerByShadowRoot","stopMutationObserver","stopInputObserver","entry","childrenLength","childElementCount","controllerByShadowRootSize","size","html","innerHTML","substring","emit","Error","scrollPositionsByElement","scrollingElement","takeFullSnapshot","location","initialOffset","left","top","p","mouseInteractionRecord","positions","r","d","frustrationRecord","stopObservers","flushMutationsFromObservers","flushMutations","takeSubsequentFullSnapshot","startRecording","httpRequest","replayRequest","sessionReplayEndpointBuilder","error","notify","applicationId","addRecord","stopSegmentCollection","unsubscribeViewEnded","unsubscribeViewCreated","view","startClocks","timeStamp","statsPerView","MAX_STATS_HISTORY","getSegmentsCount","viewId","getOrCreateReplayStats","segments_count","addSegment","records_count","addWroteData","additionalBytesCount","segments_total_raw_size","replayStats","next","isFirst_1","_value","key","deleteOldestStats"],"sourceRoot":""}