{"version":3,"file":"recorder.059b7557eb4781e4918b.js","mappings":"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","sources":["webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializationUtils.js","webpack:///../../node_modules/@datadog/browser-rum/esm/types/sessionReplayConstants.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeStyleSheets.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeAttribute.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeAttributes.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeNode.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/serialization/serializeDocument.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/eventsUtils.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/viewports.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/assembly.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackMove.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackMouseInteraction.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackScroll.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackViewportResize.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackMediaInteraction.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackStyleSheet.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackFocus.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackFrustration.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackViewEnd.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackInput.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/trackers/trackMutation.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/mutationBatch.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/record.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/elementsScrollPositions.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/shadowRootsController.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/startFullSnapshots.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/record/recordIds.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/segmentCollection/segment.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/segmentCollection/segmentCollection.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/segmentCollection/buildReplayPayload.js","webpack:///../../node_modules/@datadog/browser-rum/esm/boot/startRecording.js","webpack:///../../node_modules/@datadog/browser-rum/esm/domain/startRecordBridge.js"],"sourcesContent":["import { buildUrl } from '@datadog/browser-core';\nimport { getParentNode, isNodeShadowRoot, CENSORED_STRING_MARK, shouldMaskNode } from '@datadog/browser-rum-core';\nconst serializedNodeIds = new WeakMap();\nexport function hasSerializedNode(node) {\n    return serializedNodeIds.has(node);\n}\nexport function nodeAndAncestorsHaveSerializedNode(node) {\n    let 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    const tagName = element.tagName;\n    const value = element.value;\n    if (shouldMaskNode(element, nodePrivacyLevel)) {\n        const 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 const URL_IN_CSS_REF = /url\\((?:(')([^']*)'|(\")([^\"]*)\"|([^)]*))\\)/gm;\nexport const ABSOLUTE_URL = /^[A-Za-z]+:|^\\/\\//;\nexport const DATA_URI = /^data:.*,/i;\nexport function switchToAbsoluteUrl(cssText, cssHref) {\n    return cssText.replace(URL_IN_CSS_REF, (matchingSubstring, singleQuote, urlWrappedInSingleQuotes, doubleQuote, urlWrappedInDoubleQuotes, urlNotWrappedInQuotes) => {\n        const url = urlWrappedInSingleQuotes || urlWrappedInDoubleQuotes || urlNotWrappedInQuotes;\n        if (!cssHref || !url || ABSOLUTE_URL.test(url) || DATA_URI.test(url)) {\n            return matchingSubstring;\n        }\n        const quote = singleQuote || doubleQuote || '';\n        return `url(${quote}${makeUrlAbsolute(url, cssHref)}${quote})`;\n    });\n}\nexport function makeUrlAbsolute(url, baseUrl) {\n    try {\n        return buildUrl(url, baseUrl).href;\n    }\n    catch (_a) {\n        return url;\n    }\n}\nconst TAG_NAME_REGEX = /[^a-z1-6-_]/;\nexport function getValidTagName(tagName) {\n    const 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}\nexport function censoredImageForSize(width, height) {\n    return `data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='${width}' height='${height}' style='background-color:silver'%3E%3C/svg%3E`;\n}\n//# sourceMappingURL=serializationUtils.js.map","export const RecordType = {\n    FullSnapshot: 2,\n    IncrementalSnapshot: 3,\n    Meta: 4,\n    Focus: 6,\n    ViewEnd: 7,\n    VisualViewport: 8,\n    FrustrationRecord: 9,\n};\nexport const NodeType = {\n    Document: 0,\n    DocumentType: 1,\n    Element: 2,\n    Text: 3,\n    CDATA: 4,\n    DocumentFragment: 11,\n};\nexport const IncrementalSource = {\n    Mutation: 0,\n    MouseMove: 1,\n    MouseInteraction: 2,\n    Scroll: 3,\n    ViewportResize: 4,\n    Input: 5,\n    TouchMove: 6,\n    MediaInteraction: 7,\n    StyleSheetRule: 8,\n    // CanvasMutation : 9,\n    // Font : 10,\n};\nexport const MouseInteractionType = {\n    MouseUp: 0,\n    MouseDown: 1,\n    Click: 2,\n    ContextMenu: 3,\n    DblClick: 4,\n    Focus: 5,\n    Blur: 6,\n    TouchStart: 7,\n    TouchEnd: 9,\n};\nexport const MediaInteractionType = {\n    Play: 0,\n    Pause: 1,\n};\n//# sourceMappingURL=sessionReplayConstants.js.map","export function serializeStyleSheets(cssStyleSheets) {\n    if (cssStyleSheets === undefined || cssStyleSheets.length === 0) {\n        return undefined;\n    }\n    return cssStyleSheets.map((cssStyleSheet) => {\n        const rules = cssStyleSheet.cssRules || cssStyleSheet.rules;\n        const cssRules = Array.from(rules, (cssRule) => cssRule.cssText);\n        const styleSheet = {\n            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=serializeStyleSheets.js.map","import { NodePrivacyLevel, PRIVACY_ATTR_NAME, CENSORED_STRING_MARK, CENSORED_IMG_MARK, STABLE_ATTRIBUTES, isLongDataUrl, sanitizeDataUrl, } from '@datadog/browser-rum-core';\nimport { censoredImageForSize } from './serializationUtils';\nexport function serializeAttribute(element, nodePrivacyLevel, attributeName, configuration) {\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        // dup condition for direct access case\n        return null;\n    }\n    const attributeValue = element.getAttribute(attributeName);\n    if (nodePrivacyLevel === NodePrivacyLevel.MASK &&\n        attributeName !== PRIVACY_ATTR_NAME &&\n        !STABLE_ATTRIBUTES.includes(attributeName) &&\n        attributeName !== configuration.actionNameAttribute) {\n        const 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' && (attributeName === 'src' || attributeName === 'srcset')) {\n            // generate image with similar dimension than the original to have the same rendering behaviour\n            const image = element;\n            if (image.naturalWidth > 0) {\n                return censoredImageForSize(image.naturalWidth, image.naturalHeight);\n            }\n            const { width, height } = element.getBoundingClientRect();\n            if (width > 0 || height > 0) {\n                return censoredImageForSize(width, height);\n            }\n            // if we can't get the image size, fallback to the censored image\n            return CENSORED_IMG_MARK;\n        }\n        // mask source URLs\n        if (tagName === 'SOURCE' && (attributeName === 'src' || attributeName === 'srcset')) {\n            return CENSORED_IMG_MARK;\n        }\n        // mask <a> URLs\n        if (tagName === 'A' && attributeName === 'href') {\n            return CENSORED_STRING_MARK;\n        }\n        // mask data-* attributes\n        if (attributeValue && attributeName.startsWith('data-')) {\n            // Exception: it's safe to reveal the `${PRIVACY_ATTR_NAME}` attr\n            return CENSORED_STRING_MARK;\n        }\n        // mask iframe srcdoc\n        if (tagName === 'IFRAME' && attributeName === 'srcdoc') {\n            return CENSORED_STRING_MARK;\n        }\n    }\n    if (!attributeValue || typeof attributeValue !== 'string') {\n        return attributeValue;\n    }\n    // Minimum Fix for customer.\n    if (isLongDataUrl(attributeValue)) {\n        return sanitizeDataUrl(attributeValue);\n    }\n    return attributeValue;\n}\n//# sourceMappingURL=serializeAttribute.js.map","import { NodePrivacyLevel, shouldMaskNode } from '@datadog/browser-rum-core';\nimport { isSafari } from '@datadog/browser-core';\nimport { getElementInputValue, switchToAbsoluteUrl, getValidTagName } from './serializationUtils';\nimport { serializeAttribute } from './serializeAttribute';\nexport function serializeAttributes(element, nodePrivacyLevel, options) {\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        return {};\n    }\n    const safeAttrs = {};\n    const tagName = getValidTagName(element.tagName);\n    const doc = element.ownerDocument;\n    for (let i = 0; i < element.attributes.length; i += 1) {\n        const attribute = element.attributes.item(i);\n        const attributeName = attribute.name;\n        const 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        const 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        const optionElement = element;\n        if (optionElement.selected) {\n            safeAttrs.selected = optionElement.selected;\n        }\n    }\n    // remote css\n    if (tagName === 'link') {\n        const stylesheet = Array.from(doc.styleSheets).find((s) => s.href === element.href);\n        const cssText = getCssRulesString(stylesheet);\n        if (cssText && stylesheet) {\n            safeAttrs._cssText = cssText;\n        }\n    }\n    // dynamic stylesheet\n    if (tagName === 'style' && element.sheet) {\n        const 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    const 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        const 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    let scrollTop;\n    let scrollLeft;\n    const serializationContext = options.serializationContext;\n    switch (serializationContext.status) {\n        case 0 /* SerializationContextStatus.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, scrollLeft });\n            }\n            break;\n        case 1 /* SerializationContextStatus.SUBSEQUENT_FULL_SNAPSHOT */:\n            if (serializationContext.elementsScrollPositions.has(element)) {\n                ;\n                ({ scrollTop, scrollLeft } = serializationContext.elementsScrollPositions.get(element));\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}\nexport function getCssRulesString(cssStyleSheet) {\n    if (!cssStyleSheet) {\n        return null;\n    }\n    let 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    const styleSheetCssText = Array.from(rules, isSafari() ? getCssRuleStringForSafari : getCssRuleString).join('');\n    return switchToAbsoluteUrl(styleSheetCssText, cssStyleSheet.href);\n}\nfunction getCssRuleStringForSafari(rule) {\n    // Safari does not escape attribute selectors containing : properly\n    // https://bugs.webkit.org/show_bug.cgi?id=184604\n    if (isCSSStyleRule(rule) && rule.selectorText.includes(':')) {\n        // This regex replaces [foo:bar] by [foo\\\\:bar]\n        const escapeColon = /(\\[[\\w-]+[^\\\\])(:[^\\]]+\\])/g;\n        return rule.cssText.replace(escapeColon, '$1\\\\$2');\n    }\n    return getCssRuleString(rule);\n}\nfunction getCssRuleString(rule) {\n    // If it's an @import rule, try to inline sub-rules recursively with `getCssRulesString`. This\n    // operation can fail if the imported stylesheet is protected by CORS, in which case we fallback\n    // to the @import rule CSS text.\n    return (isCSSImportRule(rule) && getCssRulesString(rule.styleSheet)) || rule.cssText;\n}\nfunction isCSSImportRule(rule) {\n    return 'styleSheet' in rule;\n}\nfunction isCSSStyleRule(rule) {\n    return 'selectorText' in rule;\n}\n//# sourceMappingURL=serializeAttributes.js.map","import { reducePrivacyLevel, getNodeSelfPrivacyLevel, getTextContent, isNodeShadowRoot, hasChildNodes, forEachChildNodes, NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_HIDDEN, } from '@datadog/browser-rum-core';\nimport { NodeType } from '../../../types';\nimport { getSerializedNodeId, getValidTagName, setSerializedNodeId } from './serializationUtils';\nimport { serializeStyleSheets } from './serializeStyleSheets';\nimport { serializeAttributes } from './serializeAttributes';\nexport function serializeNodeWithId(node, options) {\n    const serializedNode = serializeNode(node, options);\n    if (!serializedNode) {\n        return null;\n    }\n    // Try to reuse the previous id\n    const id = getSerializedNodeId(node) || generateNextId();\n    const serializedNodeWithId = serializedNode;\n    serializedNodeWithId.id = id;\n    setSerializedNodeId(node, id);\n    if (options.serializedNodeIds) {\n        options.serializedNodeIds.add(id);\n    }\n    return serializedNodeWithId;\n}\nlet _nextId = 1;\nexport function generateNextId() {\n    return _nextId++;\n}\nexport function serializeChildNodes(node, options) {\n    const result = [];\n    forEachChildNodes(node, (childNode) => {\n        const serializedChildNode = serializeNodeWithId(childNode, options);\n        if (serializedChildNode) {\n            result.push(serializedChildNode);\n        }\n    });\n    return result;\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 serializeDocumentFragmentNode(element, options) {\n    const isShadowRoot = isNodeShadowRoot(element);\n    if (isShadowRoot) {\n        options.serializationContext.shadowRootsController.addShadowRoot(element);\n    }\n    return {\n        type: NodeType.DocumentFragment,\n        childNodes: serializeChildNodes(element, options),\n        isShadowRoot,\n        adoptedStyleSheets: isShadowRoot ? serializeStyleSheets(element.adoptedStyleSheets) : undefined,\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}\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 */\nfunction serializeElementNode(element, options) {\n    const tagName = getValidTagName(element.tagName);\n    const 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    const nodePrivacyLevel = reducePrivacyLevel(getNodeSelfPrivacyLevel(element), options.parentNodePrivacyLevel);\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        const { width, height } = element.getBoundingClientRect();\n        return {\n            type: NodeType.Element,\n            tagName,\n            attributes: {\n                rr_width: `${width}px`,\n                rr_height: `${height}px`,\n                [PRIVACY_ATTR_NAME]: PRIVACY_ATTR_VALUE_HIDDEN,\n            },\n            childNodes: [],\n            isSVG,\n        };\n    }\n    // Ignore Elements like Script and some Link, Metas\n    if (nodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n        return;\n    }\n    const attributes = serializeAttributes(element, nodePrivacyLevel, options);\n    let childNodes = [];\n    if (hasChildNodes(element) &&\n        // Do not serialize style children as the css rules are already in the _cssText attribute\n        tagName !== 'style') {\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        let childNodesSerializationOptions;\n        if (options.parentNodePrivacyLevel === nodePrivacyLevel && options.ignoreWhiteSpace === (tagName === 'head')) {\n            childNodesSerializationOptions = options;\n        }\n        else {\n            childNodesSerializationOptions = {\n                ...options,\n                parentNodePrivacyLevel: nodePrivacyLevel,\n                ignoreWhiteSpace: tagName === 'head',\n            };\n        }\n        childNodes = serializeChildNodes(element, childNodesSerializationOptions);\n    }\n    return {\n        type: NodeType.Element,\n        tagName,\n        attributes,\n        childNodes,\n        isSVG,\n    };\n}\nfunction isSVGElement(el) {\n    return el.tagName === 'svg' || el instanceof SVGElement;\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    const textContent = getTextContent(textNode, options.ignoreWhiteSpace || false, options.parentNodePrivacyLevel);\n    if (textContent === undefined) {\n        return;\n    }\n    return {\n        type: NodeType.Text,\n        textContent,\n    };\n}\nfunction serializeCDataNode() {\n    return {\n        type: NodeType.CDATA,\n        textContent: '',\n    };\n}\n//# sourceMappingURL=serializeNode.js.map","import { serializeNodeWithId } from './serializeNode';\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,\n        parentNodePrivacyLevel: configuration.defaultPrivacyLevel,\n        configuration,\n    });\n}\n//# sourceMappingURL=serializeDocument.js.map","import { isNodeShadowHost } from '@datadog/browser-rum-core';\nexport function isTouchEvent(event) {\n    return Boolean(event.changedTouches);\n}\nexport function getEventTarget(event) {\n    if (event.composed === true && isNodeShadowHost(event.target)) {\n        return event.composedPath()[0];\n    }\n    return event.target;\n}\n//# sourceMappingURL=eventsUtils.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\nconst 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(visualViewport) {\n    return (Math.abs(visualViewport.pageTop - visualViewport.offsetTop - window.scrollY) > TOLERANCE ||\n        Math.abs(visualViewport.pageLeft - visualViewport.offsetLeft - window.scrollX) > TOLERANCE);\n}\nexport const convertMouseEventToLayoutCoordinates = (clientX, clientY) => {\n    const visualViewport = window.visualViewport;\n    const normalized = {\n        layoutViewportX: clientX,\n        layoutViewportY: clientY,\n        visualViewportX: clientX,\n        visualViewportY: clientY,\n    };\n    if (!visualViewport) {\n        // On old browsers, we cannot normalize, so fallback to clientX/Y\n        return normalized;\n    }\n    else if (isVisualViewportFactoredIn(visualViewport)) {\n        // Typically Mobile Devices\n        normalized.layoutViewportX = Math.round(clientX + visualViewport.offsetLeft);\n        normalized.layoutViewportY = Math.round(clientY + visualViewport.offsetTop);\n    }\n    else {\n        // Typically Desktop Devices\n        normalized.visualViewportX = Math.round(clientX - visualViewport.offsetLeft);\n        normalized.visualViewportY = Math.round(clientY - visualViewport.offsetTop);\n    }\n    return normalized;\n};\nexport const getVisualViewport = (visualViewport) => ({\n    scale: visualViewport.scale,\n    offsetLeft: visualViewport.offsetLeft,\n    offsetTop: visualViewport.offsetTop,\n    pageLeft: visualViewport.pageLeft,\n    pageTop: visualViewport.pageTop,\n    height: visualViewport.height,\n    width: visualViewport.width,\n});\n//# sourceMappingURL=viewports.js.map","import { timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nexport function assembleIncrementalSnapshot(source, data) {\n    return {\n        data: {\n            source,\n            ...data,\n        },\n        type: RecordType.IncrementalSnapshot,\n        timestamp: timeStampNow(),\n    };\n}\n//# sourceMappingURL=assembly.js.map","import { addEventListeners, addTelemetryDebug, throttle } from '@datadog/browser-core';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { IncrementalSource } from '../../../types';\nimport { getEventTarget, isTouchEvent } from '../eventsUtils';\nimport { convertMouseEventToLayoutCoordinates } from '../viewports';\nimport { assembleIncrementalSnapshot } from '../assembly';\nconst MOUSE_MOVE_OBSERVER_THRESHOLD = 50;\nexport function trackMove(configuration, moveCb) {\n    const { throttled: updatePosition, cancel: cancelThrottle } = throttle((event) => {\n        const target = getEventTarget(event);\n        if (hasSerializedNode(target)) {\n            const coordinates = tryToComputeCoordinates(event);\n            if (!coordinates) {\n                return;\n            }\n            const position = {\n                id: getSerializedNodeId(target),\n                timeOffset: 0,\n                x: coordinates.x,\n                y: coordinates.y,\n            };\n            moveCb(assembleIncrementalSnapshot(isTouchEvent(event) ? IncrementalSource.TouchMove : IncrementalSource.MouseMove, { positions: [position] }));\n        }\n    }, MOUSE_MOVE_OBSERVER_THRESHOLD, {\n        trailing: false,\n    });\n    const { stop: removeListener } = addEventListeners(configuration, document, [\"mousemove\" /* DOM_EVENT.MOUSE_MOVE */, \"touchmove\" /* DOM_EVENT.TOUCH_MOVE */], updatePosition, {\n        capture: true,\n        passive: true,\n    });\n    return {\n        stop: () => {\n            removeListener();\n            cancelThrottle();\n        },\n    };\n}\nexport function tryToComputeCoordinates(event) {\n    let { clientX: x, clientY: y } = isTouchEvent(event) ? event.changedTouches[0] : event;\n    if (window.visualViewport) {\n        const { visualViewportX, visualViewportY } = convertMouseEventToLayoutCoordinates(x, y);\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, y };\n}\n//# sourceMappingURL=trackMove.js.map","import { addEventListeners } from '@datadog/browser-core';\nimport { getNodePrivacyLevel, NodePrivacyLevel } from '@datadog/browser-rum-core';\nimport { IncrementalSource, MouseInteractionType } from '../../../types';\nimport { assembleIncrementalSnapshot } from '../assembly';\nimport { getEventTarget } from '../eventsUtils';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { tryToComputeCoordinates } from './trackMove';\nconst eventTypeToMouseInteraction = {\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    [\"pointerup\" /* DOM_EVENT.POINTER_UP */]: MouseInteractionType.MouseUp,\n    [\"mousedown\" /* DOM_EVENT.MOUSE_DOWN */]: MouseInteractionType.MouseDown,\n    [\"click\" /* DOM_EVENT.CLICK */]: MouseInteractionType.Click,\n    [\"contextmenu\" /* DOM_EVENT.CONTEXT_MENU */]: MouseInteractionType.ContextMenu,\n    [\"dblclick\" /* DOM_EVENT.DBL_CLICK */]: MouseInteractionType.DblClick,\n    [\"focus\" /* DOM_EVENT.FOCUS */]: MouseInteractionType.Focus,\n    [\"blur\" /* DOM_EVENT.BLUR */]: MouseInteractionType.Blur,\n    [\"touchstart\" /* DOM_EVENT.TOUCH_START */]: MouseInteractionType.TouchStart,\n    [\"touchend\" /* DOM_EVENT.TOUCH_END */]: MouseInteractionType.TouchEnd,\n};\nexport function trackMouseInteraction(configuration, mouseInteractionCb, recordIds) {\n    const handler = (event) => {\n        const target = getEventTarget(event);\n        if (getNodePrivacyLevel(target, configuration.defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        const id = getSerializedNodeId(target);\n        const type = eventTypeToMouseInteraction[event.type];\n        let interaction;\n        if (type !== MouseInteractionType.Blur && type !== MouseInteractionType.Focus) {\n            const coordinates = tryToComputeCoordinates(event);\n            if (!coordinates) {\n                return;\n            }\n            interaction = { id, type, x: coordinates.x, y: coordinates.y };\n        }\n        else {\n            interaction = { id, type };\n        }\n        const record = {\n            id: recordIds.getIdForEvent(event),\n            ...assembleIncrementalSnapshot(IncrementalSource.MouseInteraction, interaction),\n        };\n        mouseInteractionCb(record);\n    };\n    return addEventListeners(configuration, document, Object.keys(eventTypeToMouseInteraction), handler, {\n        capture: true,\n        passive: true,\n    });\n}\n//# sourceMappingURL=trackMouseInteraction.js.map","import { throttle, addEventListener } from '@datadog/browser-core';\nimport { getScrollX, getScrollY, getNodePrivacyLevel, NodePrivacyLevel } from '@datadog/browser-rum-core';\nimport { getEventTarget } from '../eventsUtils';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { IncrementalSource } from '../../../types';\nimport { assembleIncrementalSnapshot } from '../assembly';\nconst SCROLL_OBSERVER_THRESHOLD = 100;\nexport function trackScroll(configuration, scrollCb, elementsScrollPositions, target = document) {\n    const { throttled: updatePosition, cancel: cancelThrottle } = throttle((event) => {\n        const target = getEventTarget(event);\n        if (!target ||\n            getNodePrivacyLevel(target, configuration.defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        const id = getSerializedNodeId(target);\n        const 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        scrollCb(assembleIncrementalSnapshot(IncrementalSource.Scroll, {\n            id,\n            x: scrollPositions.scrollLeft,\n            y: scrollPositions.scrollTop,\n        }));\n    }, SCROLL_OBSERVER_THRESHOLD);\n    const { stop: removeListener } = addEventListener(configuration, target, \"scroll\" /* DOM_EVENT.SCROLL */, updatePosition, {\n        capture: true,\n        passive: true,\n    });\n    return {\n        stop: () => {\n            removeListener();\n            cancelThrottle();\n        },\n    };\n}\n//# sourceMappingURL=trackScroll.js.map","import { throttle, addEventListeners, timeStampNow, noop } from '@datadog/browser-core';\nimport { initViewportObservable } from '@datadog/browser-rum-core';\nimport { IncrementalSource, RecordType } from '../../../types';\nimport { getVisualViewport } from '../viewports';\nimport { assembleIncrementalSnapshot } from '../assembly';\nconst VISUAL_VIEWPORT_OBSERVER_THRESHOLD = 200;\nexport function trackViewportResize(configuration, viewportResizeCb) {\n    const viewportResizeSubscription = initViewportObservable(configuration).subscribe((data) => {\n        viewportResizeCb(assembleIncrementalSnapshot(IncrementalSource.ViewportResize, data));\n    });\n    return {\n        stop: () => {\n            viewportResizeSubscription.unsubscribe();\n        },\n    };\n}\nexport function trackVisualViewportResize(configuration, visualViewportResizeCb) {\n    const visualViewport = window.visualViewport;\n    if (!visualViewport) {\n        return { stop: noop };\n    }\n    const { throttled: updateDimension, cancel: cancelThrottle } = throttle(() => {\n        visualViewportResizeCb({\n            data: getVisualViewport(visualViewport),\n            type: RecordType.VisualViewport,\n            timestamp: timeStampNow(),\n        });\n    }, VISUAL_VIEWPORT_OBSERVER_THRESHOLD, {\n        trailing: false,\n    });\n    const { stop: removeListener } = addEventListeners(configuration, visualViewport, [\"resize\" /* DOM_EVENT.RESIZE */, \"scroll\" /* DOM_EVENT.SCROLL */], updateDimension, {\n        capture: true,\n        passive: true,\n    });\n    return {\n        stop: () => {\n            removeListener();\n            cancelThrottle();\n        },\n    };\n}\n//# sourceMappingURL=trackViewportResize.js.map","import { addEventListeners } from '@datadog/browser-core';\nimport { NodePrivacyLevel, getNodePrivacyLevel } from '@datadog/browser-rum-core';\nimport { IncrementalSource, MediaInteractionType } from '../../../types';\nimport { getEventTarget } from '../eventsUtils';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { assembleIncrementalSnapshot } from '../assembly';\nexport function trackMediaInteraction(configuration, mediaInteractionCb) {\n    return addEventListeners(configuration, document, [\"play\" /* DOM_EVENT.PLAY */, \"pause\" /* DOM_EVENT.PAUSE */], (event) => {\n        const target = getEventTarget(event);\n        if (!target ||\n            getNodePrivacyLevel(target, configuration.defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        mediaInteractionCb(assembleIncrementalSnapshot(IncrementalSource.MediaInteraction, {\n            id: getSerializedNodeId(target),\n            type: event.type === \"play\" /* DOM_EVENT.PLAY */ ? MediaInteractionType.Play : MediaInteractionType.Pause,\n        }));\n    }, {\n        capture: true,\n        passive: true,\n    });\n}\n//# sourceMappingURL=trackMediaInteraction.js.map","import { instrumentMethod } from '@datadog/browser-core';\nimport { IncrementalSource } from '../../../types';\nimport { getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { assembleIncrementalSnapshot } from '../assembly';\nexport function trackStyleSheet(styleSheetCb) {\n    function checkStyleSheetAndCallback(styleSheet, callback) {\n        if (styleSheet && hasSerializedNode(styleSheet.ownerNode)) {\n            callback(getSerializedNodeId(styleSheet.ownerNode));\n        }\n    }\n    const instrumentationStoppers = [\n        instrumentMethod(CSSStyleSheet.prototype, 'insertRule', ({ target: styleSheet, parameters: [rule, index] }) => {\n            checkStyleSheetAndCallback(styleSheet, (id) => styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                id,\n                adds: [{ rule, index }],\n            })));\n        }),\n        instrumentMethod(CSSStyleSheet.prototype, 'deleteRule', ({ target: styleSheet, parameters: [index] }) => {\n            checkStyleSheetAndCallback(styleSheet, (id) => styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                id,\n                removes: [{ 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(instrumentMethod(cls.prototype, 'insertRule', ({ target: styleSheet, parameters: [rule, index] }) => {\n            checkStyleSheetAndCallback(styleSheet.parentStyleSheet, (id) => {\n                const path = getPathToNestedCSSRule(styleSheet);\n                if (path) {\n                    path.push(index || 0);\n                    styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                        id,\n                        adds: [{ rule, index: path }],\n                    }));\n                }\n            });\n        }), instrumentMethod(cls.prototype, 'deleteRule', ({ target: styleSheet, parameters: [index] }) => {\n            checkStyleSheetAndCallback(styleSheet.parentStyleSheet, (id) => {\n                const path = getPathToNestedCSSRule(styleSheet);\n                if (path) {\n                    path.push(index);\n                    styleSheetCb(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, {\n                        id,\n                        removes: [{ index: path }],\n                    }));\n                }\n            });\n        }));\n    }\n    return {\n        stop: () => {\n            instrumentationStoppers.forEach((stopper) => stopper.stop());\n        },\n    };\n}\nexport function getPathToNestedCSSRule(rule) {\n    const path = [];\n    let currentRule = rule;\n    while (currentRule.parentRule) {\n        const rules = Array.from(currentRule.parentRule.cssRules);\n        const index = rules.indexOf(currentRule);\n        path.unshift(index);\n        currentRule = currentRule.parentRule;\n    }\n    // A rule may not be attached to a stylesheet\n    if (!currentRule.parentStyleSheet) {\n        return;\n    }\n    const rules = Array.from(currentRule.parentStyleSheet.cssRules);\n    const index = rules.indexOf(currentRule);\n    path.unshift(index);\n    return path;\n}\n//# sourceMappingURL=trackStyleSheet.js.map","import { addEventListeners, timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../../types';\nexport function trackFocus(configuration, focusCb) {\n    return addEventListeners(configuration, window, [\"focus\" /* DOM_EVENT.FOCUS */, \"blur\" /* DOM_EVENT.BLUR */], () => {\n        focusCb({\n            data: { has_focus: document.hasFocus() },\n            type: RecordType.Focus,\n            timestamp: timeStampNow(),\n        });\n    });\n}\n//# sourceMappingURL=trackFocus.js.map","import { RecordType } from '../../../types';\nexport function trackFrustration(lifeCycle, frustrationCb, recordIds) {\n    const frustrationSubscription = lifeCycle.subscribe(12 /* LifeCycleEventType.RAW_RUM_EVENT_COLLECTED */, (data) => {\n        var _a, _b;\n        if (data.rawRumEvent.type === \"action\" /* RumEventType.ACTION */ &&\n            data.rawRumEvent.action.type === \"click\" /* ActionType.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            data.domainContext.events &&\n            data.domainContext.events.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((e) => recordIds.getIdForEvent(e)),\n                },\n            });\n        }\n    });\n    return {\n        stop: () => {\n            frustrationSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackFrustration.js.map","import { timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../../types';\nexport function trackViewEnd(lifeCycle, viewEndCb) {\n    const viewEndSubscription = lifeCycle.subscribe(5 /* LifeCycleEventType.VIEW_ENDED */, () => {\n        viewEndCb({\n            timestamp: timeStampNow(),\n            type: RecordType.ViewEnd,\n        });\n    });\n    return {\n        stop: () => {\n            viewEndSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackViewEnd.js.map","import { instrumentSetter, addEventListeners, noop } from '@datadog/browser-core';\nimport { NodePrivacyLevel, getNodePrivacyLevel, shouldMaskNode } from '@datadog/browser-rum-core';\nimport { IncrementalSource } from '../../../types';\nimport { getEventTarget } from '../eventsUtils';\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode } from '../serialization';\nimport { assembleIncrementalSnapshot } from '../assembly';\nexport function trackInput(configuration, inputCb, target = document) {\n    const defaultPrivacyLevel = configuration.defaultPrivacyLevel;\n    const lastInputStateMap = new WeakMap();\n    const isShadowRoot = target !== document;\n    const { stop: stopEventListeners } = addEventListeners(configuration, target, \n    // The 'input' event bubbles across shadow roots, so we don't have to listen for it on shadow\n    // roots since it will be handled by the event listener that we did add to the document. Only\n    // the 'change' event is blocked and needs to be handled on shadow roots.\n    isShadowRoot ? [\"change\" /* DOM_EVENT.CHANGE */] : [\"input\" /* DOM_EVENT.INPUT */, \"change\" /* DOM_EVENT.CHANGE */], (event) => {\n        const 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    });\n    let stopPropertySetterInstrumentation;\n    if (!isShadowRoot) {\n        const 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        stopPropertySetterInstrumentation = () => {\n            instrumentationStoppers.forEach((stopper) => stopper.stop());\n        };\n    }\n    else {\n        stopPropertySetterInstrumentation = noop;\n    }\n    return {\n        stop: () => {\n            stopPropertySetterInstrumentation();\n            stopEventListeners();\n        },\n    };\n    function onElementChange(target) {\n        const nodePrivacyLevel = getNodePrivacyLevel(target, defaultPrivacyLevel);\n        if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n            return;\n        }\n        const type = target.type;\n        let inputState;\n        if (type === 'radio' || type === 'checkbox') {\n            if (shouldMaskNode(target, nodePrivacyLevel)) {\n                return;\n            }\n            inputState = { isChecked: target.checked };\n        }\n        else {\n            const 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        const name = target.name;\n        if (type === 'radio' && name && target.checked) {\n            document.querySelectorAll(`input[type=\"radio\"][name=\"${CSS.escape(name)}\"]`).forEach((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        const lastInputState = lastInputStateMap.get(target);\n        if (!lastInputState ||\n            lastInputState.text !== inputState.text ||\n            lastInputState.isChecked !== inputState.isChecked) {\n            lastInputStateMap.set(target, inputState);\n            inputCb(assembleIncrementalSnapshot(IncrementalSource.Input, {\n                id: getSerializedNodeId(target),\n                ...inputState,\n            }));\n        }\n    }\n}\n//# sourceMappingURL=trackInput.js.map","import { monitor, noop } from '@datadog/browser-core';\nimport { isNodeShadowHost, getMutationObserverConstructor, getParentNode, forEachChildNodes, getNodePrivacyLevel, getTextContent, NodePrivacyLevel, } from '@datadog/browser-rum-core';\nimport { IncrementalSource } from '../../../types';\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode, nodeAndAncestorsHaveSerializedNode, serializeNodeWithId, serializeAttribute, } from '../serialization';\nimport { createMutationBatch } from '../mutationBatch';\nimport { assembleIncrementalSnapshot } from '../assembly';\n/**\n * Buffers and aggregate mutations generated by a MutationObserver into MutationPayload\n */\nexport function trackMutation(mutationCallback, configuration, shadowRootsController, target) {\n    const MutationObserver = getMutationObserverConstructor();\n    if (!MutationObserver) {\n        return { stop: noop, flush: noop };\n    }\n    const mutationBatch = createMutationBatch((mutations) => {\n        processMutations(mutations.concat(observer.takeRecords()), mutationCallback, configuration, shadowRootsController);\n    });\n    const 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: () => {\n            observer.disconnect();\n            mutationBatch.stop();\n        },\n        flush: () => {\n            mutationBatch.flush();\n        },\n    };\n}\nfunction processMutations(mutations, mutationCallback, configuration, shadowRootsController) {\n    const nodePrivacyLevelCache = new Map();\n    mutations\n        .filter((mutation) => mutation.type === 'childList')\n        .forEach((mutation) => {\n        mutation.removedNodes.forEach((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    const filteredMutations = mutations.filter((mutation) => mutation.target.isConnected &&\n        nodeAndAncestorsHaveSerializedNode(mutation.target) &&\n        getNodePrivacyLevel(mutation.target, configuration.defaultPrivacyLevel, nodePrivacyLevelCache) !==\n            NodePrivacyLevel.HIDDEN);\n    const { adds, removes, hasBeenSerialized } = processChildListMutations(filteredMutations.filter((mutation) => mutation.type === 'childList'), configuration, shadowRootsController, nodePrivacyLevelCache);\n    const texts = processCharacterDataMutations(filteredMutations.filter((mutation) => mutation.type === 'characterData' && !hasBeenSerialized(mutation.target)), configuration, nodePrivacyLevelCache);\n    const attributes = processAttributesMutations(filteredMutations.filter((mutation) => mutation.type === 'attributes' && !hasBeenSerialized(mutation.target)), configuration, nodePrivacyLevelCache);\n    if (!texts.length && !attributes.length && !removes.length && !adds.length) {\n        return;\n    }\n    mutationCallback(assembleIncrementalSnapshot(IncrementalSource.Mutation, { adds, removes, texts, attributes }));\n}\nfunction processChildListMutations(mutations, configuration, shadowRootsController, nodePrivacyLevelCache) {\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    const addedAndMovedNodes = new Set();\n    const removedNodes = new Map();\n    for (const mutation of mutations) {\n        mutation.addedNodes.forEach((node) => {\n            addedAndMovedNodes.add(node);\n        });\n        mutation.removedNodes.forEach((node) => {\n            if (!addedAndMovedNodes.has(node)) {\n                removedNodes.set(node, mutation.target);\n            }\n            addedAndMovedNodes.delete(node);\n        });\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    const 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    const serializedNodeIds = new Set();\n    const addedNodeMutations = [];\n    for (const node of sortedAddedAndMovedNodes) {\n        if (hasBeenSerialized(node)) {\n            continue;\n        }\n        const parentNodePrivacyLevel = getNodePrivacyLevel(node.parentNode, configuration.defaultPrivacyLevel, nodePrivacyLevelCache);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        const serializedNode = serializeNodeWithId(node, {\n            serializedNodeIds,\n            parentNodePrivacyLevel,\n            serializationContext: { status: 2 /* SerializationContextStatus.MUTATION */, shadowRootsController },\n            configuration,\n        });\n        if (!serializedNode) {\n            continue;\n        }\n        const 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    const removedNodeMutations = [];\n    removedNodes.forEach((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 };\n    function hasBeenSerialized(node) {\n        return hasSerializedNode(node) && serializedNodeIds.has(getSerializedNodeId(node));\n    }\n    function getNextSibling(node) {\n        let 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, nodePrivacyLevelCache) {\n    var _a;\n    const textMutations = [];\n    // Deduplicate mutations based on their target node\n    const handledNodes = new Set();\n    const filteredMutations = mutations.filter((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 (const mutation of filteredMutations) {\n        const value = mutation.target.textContent;\n        if (value === mutation.oldValue) {\n            continue;\n        }\n        const parentNodePrivacyLevel = getNodePrivacyLevel(getParentNode(mutation.target), configuration.defaultPrivacyLevel, nodePrivacyLevelCache);\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, nodePrivacyLevelCache) {\n    const attributeMutations = [];\n    // Deduplicate mutations based on their target node and changed attribute\n    const handledElements = new Map();\n    const filteredMutations = mutations.filter((mutation) => {\n        const handledAttributes = handledElements.get(mutation.target);\n        if (handledAttributes && 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    const emittedMutations = new Map();\n    for (const mutation of filteredMutations) {\n        const uncensoredValue = mutation.target.getAttribute(mutation.attributeName);\n        if (uncensoredValue === mutation.oldValue) {\n            continue;\n        }\n        const privacyLevel = getNodePrivacyLevel(mutation.target, configuration.defaultPrivacyLevel, nodePrivacyLevelCache);\n        const attributeValue = serializeAttribute(mutation.target, privacyLevel, mutation.attributeName, configuration);\n        let transformedValue;\n        if (mutation.attributeName === 'value') {\n            const 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        let 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((a, b) => {\n        const 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    forEachChildNodes(removedNode, (childNode) => traverseRemovedShadowDom(childNode, shadowDomRemovedCallback));\n}\n//# sourceMappingURL=trackMutation.js.map","import { noop, throttle, 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 */\nconst MUTATION_PROCESS_MAX_DELAY = 100;\n/**\n * Minimum duration to wait before processing mutations. This is used to batch mutations together\n * and be able to deduplicate them to save processing time and bandwidth.\n * 16ms is the duration of a frame at 60fps that ensure fluid UI.\n */\nexport const MUTATION_PROCESS_MIN_DELAY = 16;\nexport function createMutationBatch(processMutationBatch) {\n    let cancelScheduledFlush = noop;\n    let pendingMutations = [];\n    function flush() {\n        cancelScheduledFlush();\n        processMutationBatch(pendingMutations);\n        pendingMutations = [];\n    }\n    const { throttled: throttledFlush, cancel: cancelThrottle } = throttle(flush, MUTATION_PROCESS_MIN_DELAY, {\n        leading: false,\n    });\n    return {\n        addMutations: (mutations) => {\n            if (pendingMutations.length === 0) {\n                cancelScheduledFlush = requestIdleCallback(throttledFlush, { timeout: MUTATION_PROCESS_MAX_DELAY });\n            }\n            pendingMutations.push(...mutations);\n        },\n        flush,\n        stop: () => {\n            cancelScheduledFlush();\n            cancelThrottle();\n        },\n    };\n}\n//# sourceMappingURL=mutationBatch.js.map","import { sendToExtension } from '@datadog/browser-core';\nimport * as replayStats from '../replayStats';\nimport { trackFocus, trackFrustration, trackInput, trackMediaInteraction, trackMouseInteraction, trackMove, trackMutation, trackScroll, trackStyleSheet, trackViewEnd, trackViewportResize, trackVisualViewportResize, } from './trackers';\nimport { createElementsScrollPositions } from './elementsScrollPositions';\nimport { initShadowRootsController } from './shadowRootsController';\nimport { startFullSnapshots } from './startFullSnapshots';\nimport { initRecordIds } from './recordIds';\nexport function record(options) {\n    const { emit, configuration, lifeCycle } = options;\n    // runtime checks for user options\n    if (!emit) {\n        throw new Error('emit function is required');\n    }\n    const emitAndComputeStats = (record) => {\n        emit(record);\n        sendToExtension('record', { record });\n        const view = options.viewHistory.findView();\n        replayStats.addRecord(view.id);\n    };\n    const elementsScrollPositions = createElementsScrollPositions();\n    const shadowRootsController = initShadowRootsController(configuration, emitAndComputeStats, elementsScrollPositions);\n    const { stop: stopFullSnapshots } = startFullSnapshots(elementsScrollPositions, shadowRootsController, lifeCycle, configuration, flushMutations, (records) => records.forEach((record) => emitAndComputeStats(record)));\n    function flushMutations() {\n        shadowRootsController.flush();\n        mutationTracker.flush();\n    }\n    const recordIds = initRecordIds();\n    const mutationTracker = trackMutation(emitAndComputeStats, configuration, shadowRootsController, document);\n    const trackers = [\n        mutationTracker,\n        trackMove(configuration, emitAndComputeStats),\n        trackMouseInteraction(configuration, emitAndComputeStats, recordIds),\n        trackScroll(configuration, emitAndComputeStats, elementsScrollPositions, document),\n        trackViewportResize(configuration, emitAndComputeStats),\n        trackInput(configuration, emitAndComputeStats),\n        trackMediaInteraction(configuration, emitAndComputeStats),\n        trackStyleSheet(emitAndComputeStats),\n        trackFocus(configuration, emitAndComputeStats),\n        trackVisualViewportResize(configuration, emitAndComputeStats),\n        trackFrustration(lifeCycle, emitAndComputeStats, recordIds),\n        trackViewEnd(lifeCycle, (viewEndRecord) => {\n            flushMutations();\n            emitAndComputeStats(viewEndRecord);\n        }),\n    ];\n    return {\n        stop: () => {\n            shadowRootsController.stop();\n            trackers.forEach((tracker) => tracker.stop());\n            stopFullSnapshots();\n        },\n        flushMutations,\n        shadowRootsController,\n    };\n}\n//# sourceMappingURL=record.js.map","export function createElementsScrollPositions() {\n    const scrollPositionsByElement = new WeakMap();\n    return {\n        set(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(element) {\n            return scrollPositionsByElement.get(element);\n        },\n        has(element) {\n            return scrollPositionsByElement.has(element);\n        },\n    };\n}\n//# sourceMappingURL=elementsScrollPositions.js.map","import { trackInput, trackMutation, trackScroll } from './trackers';\nexport const initShadowRootsController = (configuration, callback, elementsScrollPositions) => {\n    const controllerByShadowRoot = new Map();\n    const shadowRootsController = {\n        addShadowRoot: (shadowRoot) => {\n            if (controllerByShadowRoot.has(shadowRoot)) {\n                return;\n            }\n            const mutationTracker = trackMutation(callback, configuration, shadowRootsController, shadowRoot);\n            // The change event does not bubble up across the shadow root, we have to listen on the shadow root\n            const inputTracker = trackInput(configuration, callback, shadowRoot);\n            // The scroll event does not bubble up across the shadow root, we have to listen on the shadow root\n            const scrollTracker = trackScroll(configuration, callback, elementsScrollPositions, shadowRoot);\n            controllerByShadowRoot.set(shadowRoot, {\n                flush: () => mutationTracker.flush(),\n                stop: () => {\n                    mutationTracker.stop();\n                    inputTracker.stop();\n                    scrollTracker.stop();\n                },\n            });\n        },\n        removeShadowRoot: (shadowRoot) => {\n            const entry = controllerByShadowRoot.get(shadowRoot);\n            if (!entry) {\n                // unidentified root cause: observed in some cases with shadow DOM added by browser extensions\n                return;\n            }\n            entry.stop();\n            controllerByShadowRoot.delete(shadowRoot);\n        },\n        stop: () => {\n            controllerByShadowRoot.forEach(({ stop }) => stop());\n        },\n        flush: () => {\n            controllerByShadowRoot.forEach(({ flush }) => flush());\n        },\n    };\n    return shadowRootsController;\n};\n//# sourceMappingURL=shadowRootsController.js.map","import { getScrollX, getScrollY, getViewportDimension } from '@datadog/browser-rum-core';\nimport { timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nimport { serializeDocument } from './serialization';\nimport { getVisualViewport } from './viewports';\nexport function startFullSnapshots(elementsScrollPositions, shadowRootsController, lifeCycle, configuration, flushMutations, fullSnapshotCallback) {\n    const takeFullSnapshot = (timestamp = timeStampNow(), serializationContext = {\n        status: 0 /* SerializationContextStatus.INITIAL_FULL_SNAPSHOT */,\n        elementsScrollPositions,\n        shadowRootsController,\n    }) => {\n        const { width, height } = getViewportDimension();\n        const records = [\n            {\n                data: {\n                    height,\n                    href: window.location.href,\n                    width,\n                },\n                type: RecordType.Meta,\n                timestamp,\n            },\n            {\n                data: {\n                    has_focus: document.hasFocus(),\n                },\n                type: RecordType.Focus,\n                timestamp,\n            },\n            {\n                data: {\n                    node: serializeDocument(document, configuration, serializationContext),\n                    initialOffset: {\n                        left: getScrollX(),\n                        top: getScrollY(),\n                    },\n                },\n                type: RecordType.FullSnapshot,\n                timestamp,\n            },\n        ];\n        if (window.visualViewport) {\n            records.push({\n                data: getVisualViewport(window.visualViewport),\n                type: RecordType.VisualViewport,\n                timestamp,\n            });\n        }\n        return records;\n    };\n    fullSnapshotCallback(takeFullSnapshot());\n    const { unsubscribe } = lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, (view) => {\n        flushMutations();\n        fullSnapshotCallback(takeFullSnapshot(view.startClocks.timeStamp, {\n            shadowRootsController,\n            status: 1 /* SerializationContextStatus.SUBSEQUENT_FULL_SNAPSHOT */,\n            elementsScrollPositions,\n        }));\n    });\n    return {\n        stop: unsubscribe,\n    };\n}\n//# sourceMappingURL=startFullSnapshots.js.map","export function initRecordIds() {\n    const recordIds = new WeakMap();\n    let nextId = 1;\n    return {\n        getIdForEvent(event) {\n            if (!recordIds.has(event)) {\n                recordIds.set(event, nextId++);\n            }\n            return recordIds.get(event);\n        },\n    };\n}\n//# sourceMappingURL=recordIds.js.map","import { RecordType } from '../../types';\nimport * as replayStats from '../replayStats';\nexport function createSegment({ context, creationReason, encoder, }) {\n    let encodedBytesCount = 0;\n    const viewId = context.view.id;\n    const metadata = {\n        start: Infinity,\n        end: -Infinity,\n        creation_reason: creationReason,\n        records_count: 0,\n        has_full_snapshot: false,\n        index_in_view: replayStats.getSegmentsCount(viewId),\n        source: 'browser',\n        ...context,\n    };\n    replayStats.addSegment(viewId);\n    function addRecord(record, callback) {\n        metadata.start = Math.min(metadata.start, record.timestamp);\n        metadata.end = Math.max(metadata.end, record.timestamp);\n        metadata.records_count += 1;\n        metadata.has_full_snapshot || (metadata.has_full_snapshot = record.type === RecordType.FullSnapshot);\n        const prefix = encoder.isEmpty ? '{\"records\":[' : ',';\n        encoder.write(prefix + JSON.stringify(record), (additionalEncodedBytesCount) => {\n            encodedBytesCount += additionalEncodedBytesCount;\n            callback(encodedBytesCount);\n        });\n    }\n    function flush(callback) {\n        if (encoder.isEmpty) {\n            throw new Error('Empty segment flushed');\n        }\n        encoder.write(`],${JSON.stringify(metadata).slice(1)}\\n`);\n        encoder.finish((encoderResult) => {\n            replayStats.addWroteData(metadata.view.id, encoderResult.rawBytesCount);\n            callback(metadata, encoderResult);\n        });\n    }\n    return { addRecord, flush };\n}\n//# sourceMappingURL=segment.js.map","import { isPageExitReason, ONE_SECOND, clearTimeout, setTimeout } from '@datadog/browser-core';\nimport { buildReplayPayload } from './buildReplayPayload';\nimport { createSegment } from './segment';\nexport const SEGMENT_DURATION_LIMIT = 5 * ONE_SECOND;\n/**\n * beacon payload max queue size implementation is 64kb\n * ensure that we leave room for logs, rum and potential other users\n */\nexport let SEGMENT_BYTES_LIMIT = 60000;\n// Segments are the main data structure for session replays. They contain context information used\n// for indexing or UI needs, and a list of records (RRWeb 'events', renamed to avoid confusing\n// namings). They are stored without any processing from the intake, and fetched one after the\n// other while a session is being replayed. Their encoding (deflate) are carefully crafted to allow\n// concatenating multiple segments together. Segments have a size overhead (metadata), so our goal is to\n// build segments containing as many records as possible while complying with the various flush\n// strategies to guarantee a good replay quality.\n//\n// When the recording starts, a segment is initially created.  The segment is flushed (finalized and\n// sent) based on various events (non-exhaustive list):\n//\n// * the page visibility change or becomes to unload\n// * the segment duration reaches a limit\n// * the encoded segment bytes count reaches a limit\n// * ...\n//\n// A segment cannot be created without its context.  If the RUM session ends and no session id is\n// available when creating a new segment, records will be ignored, until the session is renewed and\n// a new session id is available.\n//\n// Empty segments (segments with no record) aren't useful and should be ignored.\n//\n// To help investigate session replays issues, each segment is created with a \"creation reason\",\n// indicating why the session has been created.\nexport function startSegmentCollection(lifeCycle, configuration, sessionManager, viewHistory, httpRequest, encoder) {\n    return doStartSegmentCollection(lifeCycle, () => computeSegmentContext(configuration.applicationId, sessionManager, viewHistory), httpRequest, encoder);\n}\nexport function doStartSegmentCollection(lifeCycle, getSegmentContext, httpRequest, encoder) {\n    let state = {\n        status: 0 /* SegmentCollectionStatus.WaitingForInitialRecord */,\n        nextSegmentCreationReason: 'init',\n    };\n    const { unsubscribe: unsubscribeViewCreated } = lifeCycle.subscribe(2 /* LifeCycleEventType.VIEW_CREATED */, () => {\n        flushSegment('view_change');\n    });\n    const { unsubscribe: unsubscribePageExited } = lifeCycle.subscribe(11 /* LifeCycleEventType.PAGE_EXITED */, (pageExitEvent) => {\n        flushSegment(pageExitEvent.reason);\n    });\n    function flushSegment(flushReason) {\n        if (state.status === 1 /* SegmentCollectionStatus.SegmentPending */) {\n            state.segment.flush((metadata, encoderResult) => {\n                const payload = buildReplayPayload(encoderResult.output, metadata, encoderResult.rawBytesCount);\n                if (isPageExitReason(flushReason)) {\n                    httpRequest.sendOnExit(payload);\n                }\n                else {\n                    httpRequest.send(payload);\n                }\n            });\n            clearTimeout(state.expirationTimeoutId);\n        }\n        if (flushReason !== 'stop') {\n            state = {\n                status: 0 /* SegmentCollectionStatus.WaitingForInitialRecord */,\n                nextSegmentCreationReason: flushReason,\n            };\n        }\n        else {\n            state = {\n                status: 2 /* SegmentCollectionStatus.Stopped */,\n            };\n        }\n    }\n    return {\n        addRecord: (record) => {\n            if (state.status === 2 /* SegmentCollectionStatus.Stopped */) {\n                return;\n            }\n            if (state.status === 0 /* SegmentCollectionStatus.WaitingForInitialRecord */) {\n                const context = getSegmentContext();\n                if (!context) {\n                    return;\n                }\n                state = {\n                    status: 1 /* SegmentCollectionStatus.SegmentPending */,\n                    segment: createSegment({ encoder, context, creationReason: state.nextSegmentCreationReason }),\n                    expirationTimeoutId: setTimeout(() => {\n                        flushSegment('segment_duration_limit');\n                    }, SEGMENT_DURATION_LIMIT),\n                };\n            }\n            state.segment.addRecord(record, (encodedBytesCount) => {\n                if (encodedBytesCount > SEGMENT_BYTES_LIMIT) {\n                    flushSegment('segment_bytes_limit');\n                }\n            });\n        },\n        stop: () => {\n            flushSegment('stop');\n            unsubscribeViewCreated();\n            unsubscribePageExited();\n        },\n    };\n}\nexport function computeSegmentContext(applicationId, sessionManager, viewHistory) {\n    const session = sessionManager.findTrackedSession();\n    const viewContext = viewHistory.findView();\n    if (!session || !viewContext) {\n        return undefined;\n    }\n    return {\n        application: {\n            id: applicationId,\n        },\n        session: {\n            id: session.id,\n        },\n        view: {\n            id: viewContext.id,\n        },\n    };\n}\nexport function setSegmentBytesLimit(newSegmentBytesLimit = 60000) {\n    SEGMENT_BYTES_LIMIT = newSegmentBytesLimit;\n}\n//# sourceMappingURL=segmentCollection.js.map","export function buildReplayPayload(data, metadata, rawSegmentBytesCount) {\n    const formData = new FormData();\n    formData.append('segment', new Blob([data], {\n        type: 'application/octet-stream',\n    }), `${metadata.session.id}-${metadata.start}`);\n    const metadataAndSegmentSizes = {\n        raw_segment_size: rawSegmentBytesCount,\n        compressed_segment_size: data.byteLength,\n        ...metadata,\n    };\n    const serializedMetadataAndSegmentSizes = JSON.stringify(metadataAndSegmentSizes);\n    formData.append('event', new Blob([serializedMetadataAndSegmentSizes], { type: 'application/json' }));\n    return { data: formData, bytesCount: data.byteLength };\n}\n//# sourceMappingURL=buildReplayPayload.js.map","import { createHttpRequest, addTelemetryDebug, canUseEventBridge } from '@datadog/browser-core';\nimport { record } from '../domain/record';\nimport { startSegmentCollection, SEGMENT_BYTES_LIMIT } from '../domain/segmentCollection';\nimport { startRecordBridge } from '../domain/startRecordBridge';\nexport function startRecording(lifeCycle, configuration, sessionManager, viewHistory, encoder, httpRequest) {\n    const cleanupTasks = [];\n    const reportError = (error) => {\n        lifeCycle.notify(14 /* LifeCycleEventType.RAW_ERROR_COLLECTED */, { error });\n        addTelemetryDebug('Error reported to customer', { 'error.message': error.message });\n    };\n    const replayRequest = httpRequest || createHttpRequest(configuration.sessionReplayEndpointBuilder, SEGMENT_BYTES_LIMIT, reportError);\n    let addRecord;\n    if (!canUseEventBridge()) {\n        const segmentCollection = startSegmentCollection(lifeCycle, configuration, sessionManager, viewHistory, replayRequest, encoder);\n        addRecord = segmentCollection.addRecord;\n        cleanupTasks.push(segmentCollection.stop);\n    }\n    else {\n        ;\n        ({ addRecord } = startRecordBridge(viewHistory));\n    }\n    const { stop: stopRecording } = record({\n        emit: addRecord,\n        configuration,\n        lifeCycle,\n        viewHistory,\n    });\n    cleanupTasks.push(stopRecording);\n    return {\n        stop: () => {\n            cleanupTasks.forEach((task) => task());\n        },\n    };\n}\n//# sourceMappingURL=startRecording.js.map","import { getEventBridge } from '@datadog/browser-core';\nexport function startRecordBridge(viewHistory) {\n    const bridge = getEventBridge();\n    return {\n        addRecord: (record) => {\n            // Get the current active view, not at the time of the record, aligning with the segment logic.\n            // This approach could potentially associate the record to an incorrect view, in case the record date is in the past (e.g. frustration records).\n            // However the risk is minimal. We could address the issue when potential negative impact are identified.\n            const view = viewHistory.findView();\n            bridge.send('record', record, view.id);\n        },\n    };\n}\n//# sourceMappingURL=startRecordBridge.js.map"],"names":["serializedNodeIds","WeakMap","hasSerializedNode","node","has","getSerializedNodeId","get","getElementInputValue","element","nodePrivacyLevel","tagName","value","type","URL_IN_CSS_REF","ABSOLUTE_URL","DATA_URI","switchToAbsoluteUrl","cssText","cssHref","replace","matchingSubstring","singleQuote","urlWrappedInSingleQuotes","doubleQuote","urlWrappedInDoubleQuotes","urlNotWrappedInQuotes","url","test","quote","baseUrl","href","_a","makeUrlAbsolute","TAG_NAME_REGEX","getValidTagName","processedTagName","toLowerCase","trim","censoredImageForSize","width","height","RecordType","NodeType","IncrementalSource","MouseInteractionType","MediaInteractionType","serializeStyleSheets","cssStyleSheets","undefined","length","map","cssStyleSheet","rules","cssRules","Array","from","cssRule","disabled","media","serializeAttribute","attributeName","configuration","attributeValue","getAttribute","actionNameAttribute","image","naturalWidth","naturalHeight","getBoundingClientRect","startsWith","getCssRulesString","getCssRuleStringForSafari","getCssRuleString","join","rule","isCSSStyleRule","selectorText","includes","escapeColon","isCSSImportRule","styleSheet","serializeNodeWithId","options","serializedNode","nodeType","DOCUMENT_NODE","document","childNodes","serializeChildNodes","adoptedStyleSheets","serializeDocumentNode","DOCUMENT_FRAGMENT_NODE","isShadowRoot","serializationContext","shadowRootsController","addShadowRoot","serializeDocumentFragmentNode","DOCUMENT_TYPE_NODE","name","documentType","publicId","systemId","ELEMENT_NODE","isSVG","el","SVGElement","parentNodePrivacyLevel","attributes","rr_width","rr_height","safeAttrs","doc","ownerDocument","i","item","formValue","optionElement","selected","stylesheet","styleSheets","find","s","_cssText","sheet","inputElement","checked","mediaElement","rr_mediaState","paused","scrollTop","scrollLeft","status","Math","round","elementsScrollPositions","set","rr_scrollLeft","rr_scrollTop","serializeAttributes","childNodesSerializationOptions","ignoreWhiteSpace","serializeElementNode","TEXT_NODE","textNode","textContent","serializeTextNode","CDATA_SECTION_NODE","serializeNode","id","_nextId","serializedNodeWithId","serializeNodeId","setSerializedNodeId","add","result","childNode","serializedChildNode","push","serializeDocument","defaultPrivacyLevel","isTouchEvent","event","Boolean","changedTouches","getEventTarget","composed","target","composedPath","convertMouseEventToLayoutCoordinates","clientX","clientY","visualViewport","window","normalized","layoutViewportX","layoutViewportY","visualViewportX","visualViewportY","abs","pageTop","offsetTop","scrollY","pageLeft","offsetLeft","scrollX","isVisualViewportFactoredIn","getVisualViewport","scale","assembleIncrementalSnapshot","source","data","timestamp","trackMove","moveCb","throttled","updatePosition","cancel","cancelThrottle","coordinates","tryToComputeCoordinates","position","timeOffset","x","y","positions","trailing","stop","removeListener","addEventListener","a","capture","passive","Number","isFinite","isTrusted","eventTypeToMouseInteraction","trackMouseInteraction","mouseInteractionCb","recordIds","Object","keys","interaction","record","getIdForEvent","trackScroll","scrollCb","scrollPositions","trackViewportResize","viewportResizeCb","viewportResizeSubscription","subscribe","unsubscribe","trackVisualViewportResize","visualViewportResizeCb","updateDimension","trackMediaInteraction","mediaInteractionCb","trackStyleSheet","styleSheetCb","checkStyleSheetAndCallback","callback","ownerNode","instrumentationStoppers","instrumentMethod","CSSStyleSheet","prototype","parameters","index","adds","removes","instrumentGroupingCSSRuleClass","cls","parentStyleSheet","path","getPathToNestedCSSRule","CSSGroupingRule","CSSMediaRule","CSSSupportsRule","forEach","stopper","currentRule","parentRule","indexOf","unshift","trackFocus","focusCb","has_focus","hasFocus","trackFrustration","lifeCycle","frustrationCb","frustrationSubscription","_b","rawRumEvent","action","frustration","domainContext","events","date","frustrationTypes","e","trackViewEnd","viewEndCb","viewEndSubscription","trackInput","inputCb","lastInputStateMap","stopEventListeners","HTMLInputElement","HTMLTextAreaElement","HTMLSelectElement","onElementChange","stopPropertySetterInstrumentation","inputState","isChecked","text","cbWithDedup","querySelectorAll","CSS","escape","lastInputState","trackMutation","mutationCallback","MutationObserver","flush","mutationBatch","processMutationBatch","cancelScheduledFlush","pendingMutations","throttledFlush","leading","addMutations","mutations","requestIdleCallback","timeout","createMutationBatch","nodePrivacyLevelCache","Map","filter","mutation","removedNodes","removedNode","traverseRemovedShadowDom","removeShadowRoot","filteredMutations","isConnected","current","nodeAndAncestorsHaveSerializedNode","hasBeenSerialized","addedAndMovedNodes","Set","addedNodes","delete","sortedAddedAndMovedNodes","nodes","sort","b","compareDocumentPosition","Node","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_CONTAINS","DOCUMENT_POSITION_FOLLOWING","DOCUMENT_POSITION_PRECEDING","addedNodeMutations","parentNode","nextId","getNextSibling","parentId","removedNodeMutations","parent","nextSibling","processChildListMutations","texts","textMutations","handledNodes","oldValue","processCharacterDataMutations","attributeMutations","handledElements","handledAttributes","emittedMutations","privacyLevel","transformedValue","inputValue","emittedMutation","processAttributesMutations","processMutations","concat","observer","takeRecords","monitor","observe","attributeOldValue","characterData","characterDataOldValue","childList","subtree","disconnect","shadowDomRemovedCallback","shadowRoot","emit","Error","emitAndComputeStats","sendToExtension","view","viewHistory","findView","replayStats","scrollPositionsByElement","scrollingElement","createElementsScrollPositions","controllerByShadowRoot","mutationTracker","inputTracker","scrollTracker","entry","initShadowRootsController","stopFullSnapshots","flushMutations","fullSnapshotCallback","takeFullSnapshot","records","location","initialOffset","left","top","startClocks","timeStamp","startFullSnapshots","initRecordIds","trackers","viewEndRecord","tracker","createSegment","context","creationReason","encoder","encodedBytesCount","viewId","metadata","start","Infinity","end","creation_reason","records_count","has_full_snapshot","index_in_view","addRecord","min","max","prefix","isEmpty","write","JSON","stringify","additionalEncodedBytesCount","slice","finish","encoderResult","rawBytesCount","SEGMENT_DURATION_LIMIT","SEGMENT_BYTES_LIMIT","startSegmentCollection","sessionManager","httpRequest","getSegmentContext","state","nextSegmentCreationReason","unsubscribeViewCreated","flushSegment","unsubscribePageExited","pageExitEvent","reason","flushReason","segment","payload","rawSegmentBytesCount","formData","FormData","append","Blob","session","metadataAndSegmentSizes","raw_segment_size","compressed_segment_size","byteLength","serializedMetadataAndSegmentSizes","bytesCount","buildReplayPayload","output","sendOnExit","send","expirationTimeoutId","doStartSegmentCollection","applicationId","findTrackedSession","viewContext","application","computeSegmentContext","startRecording","cleanupTasks","replayRequest","sessionReplayEndpointBuilder","error","notify","message","bridge","startRecordBridge","segmentCollection","stopRecording","task"],"sourceRoot":""}