@dev-2-dev/websdk-plugin-session-tracker 0.9.0

package/dist/browser.js

@@ -0,0 +1,4893 @@
+(function () {
+    'use strict';
+
+    var NodeType;
+    (function (NodeType) {
+        NodeType[NodeType["Document"] = 0] = "Document";
+        NodeType[NodeType["DocumentType"] = 1] = "DocumentType";
+        NodeType[NodeType["Element"] = 2] = "Element";
+        NodeType[NodeType["Text"] = 3] = "Text";
+        NodeType[NodeType["CDATA"] = 4] = "CDATA";
+        NodeType[NodeType["Comment"] = 5] = "Comment";
+    })(NodeType || (NodeType = {}));
+
+    function isElement(n) {
+        return n.nodeType === n.ELEMENT_NODE;
+    }
+    function isShadowRoot(n) {
+        var host = n === null || n === void 0 ? void 0 : n.host;
+        return Boolean((host === null || host === void 0 ? void 0 : host.shadowRoot) === n);
+    }
+    function isNativeShadowDom(shadowRoot) {
+        return Object.prototype.toString.call(shadowRoot) === '[object ShadowRoot]';
+    }
+    function fixBrowserCompatibilityIssuesInCSS(cssText) {
+        if (cssText.includes(' background-clip: text;') &&
+            !cssText.includes(' -webkit-background-clip: text;')) {
+            cssText = cssText.replace(' background-clip: text;', ' -webkit-background-clip: text; background-clip: text;');
+        }
+        return cssText;
+    }
+    function getCssRulesString(s) {
+        try {
+            var rules = s.rules || s.cssRules;
+            return rules
+                ? fixBrowserCompatibilityIssuesInCSS(Array.from(rules).map(getCssRuleString).join(''))
+                : null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    function getCssRuleString(rule) {
+        var cssStringified = rule.cssText;
+        if (isCSSImportRule(rule)) {
+            try {
+                cssStringified = getCssRulesString(rule.styleSheet) || cssStringified;
+            }
+            catch (_a) {
+            }
+        }
+        return cssStringified;
+    }
+    function isCSSImportRule(rule) {
+        return 'styleSheet' in rule;
+    }
+    var Mirror = (function () {
+        function Mirror() {
+            this.idNodeMap = new Map();
+            this.nodeMetaMap = new WeakMap();
+        }
+        Mirror.prototype.getId = function (n) {
+            var _a;
+            if (!n)
+                return -1;
+            var id = (_a = this.getMeta(n)) === null || _a === void 0 ? void 0 : _a.id;
+            return id !== null && id !== void 0 ? id : -1;
+        };
+        Mirror.prototype.getNode = function (id) {
+            return this.idNodeMap.get(id) || null;
+        };
+        Mirror.prototype.getIds = function () {
+            return Array.from(this.idNodeMap.keys());
+        };
+        Mirror.prototype.getMeta = function (n) {
+            return this.nodeMetaMap.get(n) || null;
+        };
+        Mirror.prototype.removeNodeFromMap = function (n) {
+            var _this = this;
+            var id = this.getId(n);
+            this.idNodeMap["delete"](id);
+            if (n.childNodes) {
+                n.childNodes.forEach(function (childNode) {
+                    return _this.removeNodeFromMap(childNode);
+                });
+            }
+        };
+        Mirror.prototype.has = function (id) {
+            return this.idNodeMap.has(id);
+        };
+        Mirror.prototype.hasNode = function (node) {
+            return this.nodeMetaMap.has(node);
+        };
+        Mirror.prototype.add = function (n, meta) {
+            var id = meta.id;
+            this.idNodeMap.set(id, n);
+            this.nodeMetaMap.set(n, meta);
+        };
+        Mirror.prototype.replace = function (id, n) {
+            var oldNode = this.getNode(id);
+            if (oldNode) {
+                var meta = this.nodeMetaMap.get(oldNode);
+                if (meta)
+                    this.nodeMetaMap.set(n, meta);
+            }
+            this.idNodeMap.set(id, n);
+        };
+        Mirror.prototype.reset = function () {
+            this.idNodeMap = new Map();
+            this.nodeMetaMap = new WeakMap();
+        };
+        return Mirror;
+    }());
+    function createMirror() {
+        return new Mirror();
+    }
+    function maskInputValue(_a) {
+        var maskInputOptions = _a.maskInputOptions, tagName = _a.tagName, type = _a.type, value = _a.value, maskInputFn = _a.maskInputFn;
+        var text = value || '';
+        if (maskInputOptions[tagName.toLowerCase()] ||
+            maskInputOptions[type]) {
+            if (maskInputFn) {
+                text = maskInputFn(text);
+            }
+            else {
+                text = '*'.repeat(text.length);
+            }
+        }
+        return text;
+    }
+    var ORIGINAL_ATTRIBUTE_NAME = '__rrweb_original__';
+    function is2DCanvasBlank(canvas) {
+        var ctx = canvas.getContext('2d');
+        if (!ctx)
+            return true;
+        var chunkSize = 50;
+        for (var x = 0; x < canvas.width; x += chunkSize) {
+            for (var y = 0; y < canvas.height; y += chunkSize) {
+                var getImageData = ctx.getImageData;
+                var originalGetImageData = ORIGINAL_ATTRIBUTE_NAME in getImageData
+                    ? getImageData[ORIGINAL_ATTRIBUTE_NAME]
+                    : getImageData;
+                var pixelBuffer = new Uint32Array(originalGetImageData.call(ctx, x, y, Math.min(chunkSize, canvas.width - x), Math.min(chunkSize, canvas.height - y)).data.buffer);
+                if (pixelBuffer.some(function (pixel) { return pixel !== 0; }))
+                    return false;
+            }
+        }
+        return true;
+    }
+
+    var _id = 1;
+    var tagNameRegex = new RegExp('[^a-z0-9-_:]');
+    var IGNORED_NODE = -2;
+    function genId() {
+        return _id++;
+    }
+    function getValidTagName(element) {
+        if (element instanceof HTMLFormElement) {
+            return 'form';
+        }
+        var processedTagName = element.tagName.toLowerCase().trim();
+        if (tagNameRegex.test(processedTagName)) {
+            return 'div';
+        }
+        return processedTagName;
+    }
+    function stringifyStyleSheet(sheet) {
+        return sheet.cssRules
+            ? Array.from(sheet.cssRules)
+                .map(function (rule) { return rule.cssText || ''; })
+                .join('')
+            : '';
+    }
+    function extractOrigin(url) {
+        var origin = '';
+        if (url.indexOf('//') > -1) {
+            origin = url.split('/').slice(0, 3).join('/');
+        }
+        else {
+            origin = url.split('/')[0];
+        }
+        origin = origin.split('?')[0];
+        return origin;
+    }
+    var canvasService;
+    var canvasCtx;
+    var URL_IN_CSS_REF = /url\((?:(')([^']*)'|(")(.*?)"|([^)]*))\)/gm;
+    var RELATIVE_PATH = /^(?!www\.|(?:http|ftp)s?:\/\/|[A-Za-z]:\\|\/\/|#).*/;
+    var DATA_URI = /^(data:)([^,]*),(.*)/i;
+    function absoluteToStylesheet(cssText, href) {
+        return (cssText || '').replace(URL_IN_CSS_REF, function (origin, quote1, path1, quote2, path2, path3) {
+            var filePath = path1 || path2 || path3;
+            var maybeQuote = quote1 || quote2 || '';
+            if (!filePath) {
+                return origin;
+            }
+            if (!RELATIVE_PATH.test(filePath)) {
+                return "url(".concat(maybeQuote).concat(filePath).concat(maybeQuote, ")");
+            }
+            if (DATA_URI.test(filePath)) {
+                return "url(".concat(maybeQuote).concat(filePath).concat(maybeQuote, ")");
+            }
+            if (filePath[0] === '/') {
+                return "url(".concat(maybeQuote).concat(extractOrigin(href) + filePath).concat(maybeQuote, ")");
+            }
+            var stack = href.split('/');
+            var parts = filePath.split('/');
+            stack.pop();
+            for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+                var part = parts_1[_i];
+                if (part === '.') {
+                    continue;
+                }
+                else if (part === '..') {
+                    stack.pop();
+                }
+                else {
+                    stack.push(part);
+                }
+            }
+            return "url(".concat(maybeQuote).concat(stack.join('/')).concat(maybeQuote, ")");
+        });
+    }
+    var SRCSET_NOT_SPACES = /^[^ \t\n\r\u000c]+/;
+    var SRCSET_COMMAS_OR_SPACES = /^[, \t\n\r\u000c]+/;
+    function getAbsoluteSrcsetString(doc, attributeValue) {
+        if (attributeValue.trim() === '') {
+            return attributeValue;
+        }
+        var pos = 0;
+        function collectCharacters(regEx) {
+            var chars;
+            var match = regEx.exec(attributeValue.substring(pos));
+            if (match) {
+                chars = match[0];
+                pos += chars.length;
+                return chars;
+            }
+            return '';
+        }
+        var output = [];
+        while (true) {
+            collectCharacters(SRCSET_COMMAS_OR_SPACES);
+            if (pos >= attributeValue.length) {
+                break;
+            }
+            var url = collectCharacters(SRCSET_NOT_SPACES);
+            if (url.slice(-1) === ',') {
+                url = absoluteToDoc(doc, url.substring(0, url.length - 1));
+                output.push(url);
+            }
+            else {
+                var descriptorsStr = '';
+                url = absoluteToDoc(doc, url);
+                var inParens = false;
+                while (true) {
+                    var c = attributeValue.charAt(pos);
+                    if (c === '') {
+                        output.push((url + descriptorsStr).trim());
+                        break;
+                    }
+                    else if (!inParens) {
+                        if (c === ',') {
+                            pos += 1;
+                            output.push((url + descriptorsStr).trim());
+                            break;
+                        }
+                        else if (c === '(') {
+                            inParens = true;
+                        }
+                    }
+                    else {
+                        if (c === ')') {
+                            inParens = false;
+                        }
+                    }
+                    descriptorsStr += c;
+                    pos += 1;
+                }
+            }
+        }
+        return output.join(', ');
+    }
+    function absoluteToDoc(doc, attributeValue) {
+        if (!attributeValue || attributeValue.trim() === '') {
+            return attributeValue;
+        }
+        var a = doc.createElement('a');
+        a.href = attributeValue;
+        return a.href;
+    }
+    function isSVGElement(el) {
+        return Boolean(el.tagName === 'svg' || el.ownerSVGElement);
+    }
+    function getHref() {
+        var a = document.createElement('a');
+        a.href = '';
+        return a.href;
+    }
+    function transformAttribute(doc, tagName, name, value) {
+        if (name === 'src' ||
+            (name === 'href' && value && !(tagName === 'use' && value[0] === '#'))) {
+            return absoluteToDoc(doc, value);
+        }
+        else if (name === 'xlink:href' && value && value[0] !== '#') {
+            return absoluteToDoc(doc, value);
+        }
+        else if (name === 'background' &&
+            value &&
+            (tagName === 'table' || tagName === 'td' || tagName === 'th')) {
+            return absoluteToDoc(doc, value);
+        }
+        else if (name === 'srcset' && value) {
+            return getAbsoluteSrcsetString(doc, value);
+        }
+        else if (name === 'style' && value) {
+            return absoluteToStylesheet(value, getHref());
+        }
+        else if (tagName === 'object' && name === 'data' && value) {
+            return absoluteToDoc(doc, value);
+        }
+        else {
+            return value;
+        }
+    }
+    function _isBlockedElement(element, blockClass, blockSelector) {
+        if (typeof blockClass === 'string') {
+            if (element.classList.contains(blockClass)) {
+                return true;
+            }
+        }
+        else {
+            for (var eIndex = element.classList.length; eIndex--;) {
+                var className = element.classList[eIndex];
+                if (blockClass.test(className)) {
+                    return true;
+                }
+            }
+        }
+        if (blockSelector) {
+            return element.matches(blockSelector);
+        }
+        return false;
+    }
+    function classMatchesRegex(node, regex, checkAncestors) {
+        if (!node)
+            return false;
+        if (node.nodeType !== node.ELEMENT_NODE) {
+            if (!checkAncestors)
+                return false;
+            return classMatchesRegex(node.parentNode, regex, checkAncestors);
+        }
+        for (var eIndex = node.classList.length; eIndex--;) {
+            var className = node.classList[eIndex];
+            if (regex.test(className)) {
+                return true;
+            }
+        }
+        if (!checkAncestors)
+            return false;
+        return classMatchesRegex(node.parentNode, regex, checkAncestors);
+    }
+    function needMaskingText(node, maskTextClass, maskTextSelector) {
+        var el = node.nodeType === node.ELEMENT_NODE
+            ? node
+            : node.parentElement;
+        if (el === null)
+            return false;
+        if (typeof maskTextClass === 'string') {
+            if (el.classList.contains(maskTextClass))
+                return true;
+            if (el.closest(".".concat(maskTextClass)))
+                return true;
+        }
+        else {
+            if (classMatchesRegex(el, maskTextClass, true))
+                return true;
+        }
+        if (maskTextSelector) {
+            if (el.matches(maskTextSelector))
+                return true;
+            if (el.closest(maskTextSelector))
+                return true;
+        }
+        return false;
+    }
+    function onceIframeLoaded(iframeEl, listener, iframeLoadTimeout) {
+        var win = iframeEl.contentWindow;
+        if (!win) {
+            return;
+        }
+        var fired = false;
+        var readyState;
+        try {
+            readyState = win.document.readyState;
+        }
+        catch (error) {
+            return;
+        }
+        if (readyState !== 'complete') {
+            var timer_1 = setTimeout(function () {
+                if (!fired) {
+                    listener();
+                    fired = true;
+                }
+            }, iframeLoadTimeout);
+            iframeEl.addEventListener('load', function () {
+                clearTimeout(timer_1);
+                fired = true;
+                listener();
+            });
+            return;
+        }
+        var blankUrl = 'about:blank';
+        if (win.location.href !== blankUrl ||
+            iframeEl.src === blankUrl ||
+            iframeEl.src === '') {
+            setTimeout(listener, 0);
+            return iframeEl.addEventListener('load', listener);
+        }
+        iframeEl.addEventListener('load', listener);
+    }
+    function onceStylesheetLoaded(link, listener, styleSheetLoadTimeout) {
+        var fired = false;
+        var styleSheetLoaded;
+        try {
+            styleSheetLoaded = link.sheet;
+        }
+        catch (error) {
+            return;
+        }
+        if (styleSheetLoaded)
+            return;
+        var timer = setTimeout(function () {
+            if (!fired) {
+                listener();
+                fired = true;
+            }
+        }, styleSheetLoadTimeout);
+        link.addEventListener('load', function () {
+            clearTimeout(timer);
+            fired = true;
+            listener();
+        });
+    }
+    function serializeNode(n, options) {
+        var doc = options.doc, mirror = options.mirror, blockClass = options.blockClass, blockSelector = options.blockSelector, maskTextClass = options.maskTextClass, maskTextSelector = options.maskTextSelector, inlineStylesheet = options.inlineStylesheet, _a = options.maskInputOptions, maskInputOptions = _a === void 0 ? {} : _a, maskTextFn = options.maskTextFn, maskInputFn = options.maskInputFn, _b = options.dataURLOptions, dataURLOptions = _b === void 0 ? {} : _b, inlineImages = options.inlineImages, recordCanvas = options.recordCanvas, keepIframeSrcFn = options.keepIframeSrcFn, _c = options.newlyAddedElement, newlyAddedElement = _c === void 0 ? false : _c;
+        var rootId = getRootId(doc, mirror);
+        switch (n.nodeType) {
+            case n.DOCUMENT_NODE:
+                if (n.compatMode !== 'CSS1Compat') {
+                    return {
+                        type: NodeType.Document,
+                        childNodes: [],
+                        compatMode: n.compatMode
+                    };
+                }
+                else {
+                    return {
+                        type: NodeType.Document,
+                        childNodes: []
+                    };
+                }
+            case n.DOCUMENT_TYPE_NODE:
+                return {
+                    type: NodeType.DocumentType,
+                    name: n.name,
+                    publicId: n.publicId,
+                    systemId: n.systemId,
+                    rootId: rootId
+                };
+            case n.ELEMENT_NODE:
+                return serializeElementNode(n, {
+                    doc: doc,
+                    blockClass: blockClass,
+                    blockSelector: blockSelector,
+                    inlineStylesheet: inlineStylesheet,
+                    maskInputOptions: maskInputOptions,
+                    maskInputFn: maskInputFn,
+                    dataURLOptions: dataURLOptions,
+                    inlineImages: inlineImages,
+                    recordCanvas: recordCanvas,
+                    keepIframeSrcFn: keepIframeSrcFn,
+                    newlyAddedElement: newlyAddedElement,
+                    rootId: rootId
+                });
+            case n.TEXT_NODE:
+                return serializeTextNode(n, {
+                    maskTextClass: maskTextClass,
+                    maskTextSelector: maskTextSelector,
+                    maskTextFn: maskTextFn,
+                    rootId: rootId
+                });
+            case n.CDATA_SECTION_NODE:
+                return {
+                    type: NodeType.CDATA,
+                    textContent: '',
+                    rootId: rootId
+                };
+            case n.COMMENT_NODE:
+                return {
+                    type: NodeType.Comment,
+                    textContent: n.textContent || '',
+                    rootId: rootId
+                };
+            default:
+                return false;
+        }
+    }
+    function getRootId(doc, mirror) {
+        if (!mirror.hasNode(doc))
+            return undefined;
+        var docId = mirror.getId(doc);
+        return docId === 1 ? undefined : docId;
+    }
+    function serializeTextNode(n, options) {
+        var _a;
+        var maskTextClass = options.maskTextClass, maskTextSelector = options.maskTextSelector, maskTextFn = options.maskTextFn, rootId = options.rootId;
+        var parentTagName = n.parentNode && n.parentNode.tagName;
+        var textContent = n.textContent;
+        var isStyle = parentTagName === 'STYLE' ? true : undefined;
+        var isScript = parentTagName === 'SCRIPT' ? true : undefined;
+        if (isStyle && textContent) {
+            try {
+                if (n.nextSibling || n.previousSibling) {
+                }
+                else if ((_a = n.parentNode.sheet) === null || _a === void 0 ? void 0 : _a.cssRules) {
+                    textContent = stringifyStyleSheet(n.parentNode.sheet);
+                }
+            }
+            catch (err) {
+                console.warn("Cannot get CSS styles from text's parentNode. Error: ".concat(err), n);
+            }
+            textContent = absoluteToStylesheet(textContent, getHref());
+        }
+        if (isScript) {
+            textContent = 'SCRIPT_PLACEHOLDER';
+        }
+        if (!isStyle &&
+            !isScript &&
+            textContent &&
+            needMaskingText(n, maskTextClass, maskTextSelector)) {
+            textContent = maskTextFn
+                ? maskTextFn(textContent)
+                : textContent.replace(/[\S]/g, '*');
+        }
+        return {
+            type: NodeType.Text,
+            textContent: textContent || '',
+            isStyle: isStyle,
+            rootId: rootId
+        };
+    }
+    function serializeElementNode(n, options) {
+        var doc = options.doc, blockClass = options.blockClass, blockSelector = options.blockSelector, inlineStylesheet = options.inlineStylesheet, _a = options.maskInputOptions, maskInputOptions = _a === void 0 ? {} : _a, maskInputFn = options.maskInputFn, _b = options.dataURLOptions, dataURLOptions = _b === void 0 ? {} : _b, inlineImages = options.inlineImages, recordCanvas = options.recordCanvas, keepIframeSrcFn = options.keepIframeSrcFn, _c = options.newlyAddedElement, newlyAddedElement = _c === void 0 ? false : _c, rootId = options.rootId;
+        var needBlock = _isBlockedElement(n, blockClass, blockSelector);
+        var tagName = getValidTagName(n);
+        var attributes = {};
+        var len = n.attributes.length;
+        for (var i = 0; i < len; i++) {
+            var attr = n.attributes[i];
+            attributes[attr.name] = transformAttribute(doc, tagName, attr.name, attr.value);
+        }
+        if (tagName === 'link' && inlineStylesheet) {
+            var stylesheet = Array.from(doc.styleSheets).find(function (s) {
+                return s.href === n.href;
+            });
+            var cssText = null;
+            if (stylesheet) {
+                cssText = getCssRulesString(stylesheet);
+            }
+            if (cssText) {
+                delete attributes.rel;
+                delete attributes.href;
+                attributes._cssText = absoluteToStylesheet(cssText, stylesheet.href);
+            }
+        }
+        if (tagName === 'style' &&
+            n.sheet &&
+            !(n.innerText || n.textContent || '').trim().length) {
+            var cssText = getCssRulesString(n.sheet);
+            if (cssText) {
+                attributes._cssText = absoluteToStylesheet(cssText, getHref());
+            }
+        }
+        if (tagName === 'input' || tagName === 'textarea' || tagName === 'select') {
+            var value = n.value;
+            var checked = n.checked;
+            if (attributes.type !== 'radio' &&
+                attributes.type !== 'checkbox' &&
+                attributes.type !== 'submit' &&
+                attributes.type !== 'button' &&
+                value) {
+                attributes.value = maskInputValue({
+                    type: attributes.type,
+                    tagName: tagName,
+                    value: value,
+                    maskInputOptions: maskInputOptions,
+                    maskInputFn: maskInputFn
+                });
+            }
+            else if (checked) {
+                attributes.checked = checked;
+            }
+        }
+        if (tagName === 'option') {
+            if (n.selected && !maskInputOptions['select']) {
+                attributes.selected = true;
+            }
+            else {
+                delete attributes.selected;
+            }
+        }
+        if (tagName === 'canvas' && recordCanvas) {
+            if (n.__context === '2d') {
+                if (!is2DCanvasBlank(n)) {
+                    attributes.rr_dataURL = n.toDataURL(dataURLOptions.type, dataURLOptions.quality);
+                }
+            }
+            else if (!('__context' in n)) {
+                var canvasDataURL = n.toDataURL(dataURLOptions.type, dataURLOptions.quality);
+                var blankCanvas = document.createElement('canvas');
+                blankCanvas.width = n.width;
+                blankCanvas.height = n.height;
+                var blankCanvasDataURL = blankCanvas.toDataURL(dataURLOptions.type, dataURLOptions.quality);
+                if (canvasDataURL !== blankCanvasDataURL) {
+                    attributes.rr_dataURL = canvasDataURL;
+                }
+            }
+        }
+        if (tagName === 'img' && inlineImages) {
+            if (!canvasService) {
+                canvasService = doc.createElement('canvas');
+                canvasCtx = canvasService.getContext('2d');
+            }
+            var image_1 = n;
+            var oldValue_1 = image_1.crossOrigin;
+            image_1.crossOrigin = 'anonymous';
+            var recordInlineImage = function () {
+                try {
+                    canvasService.width = image_1.naturalWidth;
+                    canvasService.height = image_1.naturalHeight;
+                    canvasCtx.drawImage(image_1, 0, 0);
+                    attributes.rr_dataURL = canvasService.toDataURL(dataURLOptions.type, dataURLOptions.quality);
+                }
+                catch (err) {
+                    console.warn("Cannot inline img src=".concat(image_1.currentSrc, "! Error: ").concat(err));
+                }
+                oldValue_1
+                    ? (attributes.crossOrigin = oldValue_1)
+                    : image_1.removeAttribute('crossorigin');
+            };
+            if (image_1.complete && image_1.naturalWidth !== 0)
+                recordInlineImage();
+            else
+                image_1.onload = recordInlineImage;
+        }
+        if (tagName === 'audio' || tagName === 'video') {
+            attributes.rr_mediaState = n.paused
+                ? 'paused'
+                : 'played';
+            attributes.rr_mediaCurrentTime = n.currentTime;
+        }
+        if (!newlyAddedElement) {
+            if (n.scrollLeft) {
+                attributes.rr_scrollLeft = n.scrollLeft;
+            }
+            if (n.scrollTop) {
+                attributes.rr_scrollTop = n.scrollTop;
+            }
+        }
+        if (needBlock) {
+            var _d = n.getBoundingClientRect(), width = _d.width, height = _d.height;
+            attributes = {
+                "class": attributes["class"],
+                rr_width: "".concat(width, "px"),
+                rr_height: "".concat(height, "px")
+            };
+        }
+        if (tagName === 'iframe' && !keepIframeSrcFn(attributes.src)) {
+            if (!n.contentDocument) {
+                attributes.rr_src = attributes.src;
+            }
+            delete attributes.src;
+        }
+        return {
+            type: NodeType.Element,
+            tagName: tagName,
+            attributes: attributes,
+            childNodes: [],
+            isSVG: isSVGElement(n) || undefined,
+            needBlock: needBlock,
+            rootId: rootId
+        };
+    }
+    function lowerIfExists(maybeAttr) {
+        if (maybeAttr === undefined) {
+            return '';
+        }
+        else {
+            return maybeAttr.toLowerCase();
+        }
+    }
+    function slimDOMExcluded(sn, slimDOMOptions) {
+        if (slimDOMOptions.comment && sn.type === NodeType.Comment) {
+            return true;
+        }
+        else if (sn.type === NodeType.Element) {
+            if (slimDOMOptions.script &&
+                (sn.tagName === 'script' ||
+                    (sn.tagName === 'link' &&
+                        sn.attributes.rel === 'preload' &&
+                        sn.attributes.as === 'script') ||
+                    (sn.tagName === 'link' &&
+                        sn.attributes.rel === 'prefetch' &&
+                        typeof sn.attributes.href === 'string' &&
+                        sn.attributes.href.endsWith('.js')))) {
+                return true;
+            }
+            else if (slimDOMOptions.headFavicon &&
+                ((sn.tagName === 'link' && sn.attributes.rel === 'shortcut icon') ||
+                    (sn.tagName === 'meta' &&
+                        (lowerIfExists(sn.attributes.name).match(/^msapplication-tile(image|color)$/) ||
+                            lowerIfExists(sn.attributes.name) === 'application-name' ||
+                            lowerIfExists(sn.attributes.rel) === 'icon' ||
+                            lowerIfExists(sn.attributes.rel) === 'apple-touch-icon' ||
+                            lowerIfExists(sn.attributes.rel) === 'shortcut icon')))) {
+                return true;
+            }
+            else if (sn.tagName === 'meta') {
+                if (slimDOMOptions.headMetaDescKeywords &&
+                    lowerIfExists(sn.attributes.name).match(/^description|keywords$/)) {
+                    return true;
+                }
+                else if (slimDOMOptions.headMetaSocial &&
+                    (lowerIfExists(sn.attributes.property).match(/^(og|twitter|fb):/) ||
+                        lowerIfExists(sn.attributes.name).match(/^(og|twitter):/) ||
+                        lowerIfExists(sn.attributes.name) === 'pinterest')) {
+                    return true;
+                }
+                else if (slimDOMOptions.headMetaRobots &&
+                    (lowerIfExists(sn.attributes.name) === 'robots' ||
+                        lowerIfExists(sn.attributes.name) === 'googlebot' ||
+                        lowerIfExists(sn.attributes.name) === 'bingbot')) {
+                    return true;
+                }
+                else if (slimDOMOptions.headMetaHttpEquiv &&
+                    sn.attributes['http-equiv'] !== undefined) {
+                    return true;
+                }
+                else if (slimDOMOptions.headMetaAuthorship &&
+                    (lowerIfExists(sn.attributes.name) === 'author' ||
+                        lowerIfExists(sn.attributes.name) === 'generator' ||
+                        lowerIfExists(sn.attributes.name) === 'framework' ||
+                        lowerIfExists(sn.attributes.name) === 'publisher' ||
+                        lowerIfExists(sn.attributes.name) === 'progid' ||
+                        lowerIfExists(sn.attributes.property).match(/^article:/) ||
+                        lowerIfExists(sn.attributes.property).match(/^product:/))) {
+                    return true;
+                }
+                else if (slimDOMOptions.headMetaVerification &&
+                    (lowerIfExists(sn.attributes.name) === 'google-site-verification' ||
+                        lowerIfExists(sn.attributes.name) === 'yandex-verification' ||
+                        lowerIfExists(sn.attributes.name) === 'csrf-token' ||
+                        lowerIfExists(sn.attributes.name) === 'p:domain_verify' ||
+                        lowerIfExists(sn.attributes.name) === 'verify-v1' ||
+                        lowerIfExists(sn.attributes.name) === 'verification' ||
+                        lowerIfExists(sn.attributes.name) === 'shopify-checkout-api-token')) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    function serializeNodeWithId(n, options) {
+        var doc = options.doc, mirror = options.mirror, blockClass = options.blockClass, blockSelector = options.blockSelector, maskTextClass = options.maskTextClass, maskTextSelector = options.maskTextSelector, _a = options.skipChild, skipChild = _a === void 0 ? false : _a, _b = options.inlineStylesheet, inlineStylesheet = _b === void 0 ? true : _b, _c = options.maskInputOptions, maskInputOptions = _c === void 0 ? {} : _c, maskTextFn = options.maskTextFn, maskInputFn = options.maskInputFn, slimDOMOptions = options.slimDOMOptions, _d = options.dataURLOptions, dataURLOptions = _d === void 0 ? {} : _d, _e = options.inlineImages, inlineImages = _e === void 0 ? false : _e, _f = options.recordCanvas, recordCanvas = _f === void 0 ? false : _f, onSerialize = options.onSerialize, onIframeLoad = options.onIframeLoad, _g = options.iframeLoadTimeout, iframeLoadTimeout = _g === void 0 ? 5000 : _g, onStylesheetLoad = options.onStylesheetLoad, _h = options.stylesheetLoadTimeout, stylesheetLoadTimeout = _h === void 0 ? 5000 : _h, _j = options.keepIframeSrcFn, keepIframeSrcFn = _j === void 0 ? function () { return false; } : _j, _k = options.newlyAddedElement, newlyAddedElement = _k === void 0 ? false : _k;
+        var _l = options.preserveWhiteSpace, preserveWhiteSpace = _l === void 0 ? true : _l;
+        var _serializedNode = serializeNode(n, {
+            doc: doc,
+            mirror: mirror,
+            blockClass: blockClass,
+            blockSelector: blockSelector,
+            maskTextClass: maskTextClass,
+            maskTextSelector: maskTextSelector,
+            inlineStylesheet: inlineStylesheet,
+            maskInputOptions: maskInputOptions,
+            maskTextFn: maskTextFn,
+            maskInputFn: maskInputFn,
+            dataURLOptions: dataURLOptions,
+            inlineImages: inlineImages,
+            recordCanvas: recordCanvas,
+            keepIframeSrcFn: keepIframeSrcFn,
+            newlyAddedElement: newlyAddedElement
+        });
+        if (!_serializedNode) {
+            console.warn(n, 'not serialized');
+            return null;
+        }
+        var id;
+        if (mirror.hasNode(n)) {
+            id = mirror.getId(n);
+        }
+        else if (slimDOMExcluded(_serializedNode, slimDOMOptions) ||
+            (!preserveWhiteSpace &&
+                _serializedNode.type === NodeType.Text &&
+                !_serializedNode.isStyle &&
+                !_serializedNode.textContent.replace(/^\s+|\s+$/gm, '').length)) {
+            id = IGNORED_NODE;
+        }
+        else {
+            id = genId();
+        }
+        var serializedNode = Object.assign(_serializedNode, { id: id });
+        mirror.add(n, serializedNode);
+        if (id === IGNORED_NODE) {
+            return null;
+        }
+        if (onSerialize) {
+            onSerialize(n);
+        }
+        var recordChild = !skipChild;
+        if (serializedNode.type === NodeType.Element) {
+            recordChild = recordChild && !serializedNode.needBlock;
+            delete serializedNode.needBlock;
+            var shadowRoot = n.shadowRoot;
+            if (shadowRoot && isNativeShadowDom(shadowRoot))
+                serializedNode.isShadowHost = true;
+        }
+        if ((serializedNode.type === NodeType.Document ||
+            serializedNode.type === NodeType.Element) &&
+            recordChild) {
+            if (slimDOMOptions.headWhitespace &&
+                serializedNode.type === NodeType.Element &&
+                serializedNode.tagName === 'head') {
+                preserveWhiteSpace = false;
+            }
+            var bypassOptions = {
+                doc: doc,
+                mirror: mirror,
+                blockClass: blockClass,
+                blockSelector: blockSelector,
+                maskTextClass: maskTextClass,
+                maskTextSelector: maskTextSelector,
+                skipChild: skipChild,
+                inlineStylesheet: inlineStylesheet,
+                maskInputOptions: maskInputOptions,
+                maskTextFn: maskTextFn,
+                maskInputFn: maskInputFn,
+                slimDOMOptions: slimDOMOptions,
+                dataURLOptions: dataURLOptions,
+                inlineImages: inlineImages,
+                recordCanvas: recordCanvas,
+                preserveWhiteSpace: preserveWhiteSpace,
+                onSerialize: onSerialize,
+                onIframeLoad: onIframeLoad,
+                iframeLoadTimeout: iframeLoadTimeout,
+                onStylesheetLoad: onStylesheetLoad,
+                stylesheetLoadTimeout: stylesheetLoadTimeout,
+                keepIframeSrcFn: keepIframeSrcFn
+            };
+            for (var _i = 0, _m = Array.from(n.childNodes); _i < _m.length; _i++) {
+                var childN = _m[_i];
+                var serializedChildNode = serializeNodeWithId(childN, bypassOptions);
+                if (serializedChildNode) {
+                    serializedNode.childNodes.push(serializedChildNode);
+                }
+            }
+            if (isElement(n) && n.shadowRoot) {
+                for (var _o = 0, _p = Array.from(n.shadowRoot.childNodes); _o < _p.length; _o++) {
+                    var childN = _p[_o];
+                    var serializedChildNode = serializeNodeWithId(childN, bypassOptions);
+                    if (serializedChildNode) {
+                        isNativeShadowDom(n.shadowRoot) &&
+                            (serializedChildNode.isShadow = true);
+                        serializedNode.childNodes.push(serializedChildNode);
+                    }
+                }
+            }
+        }
+        if (n.parentNode &&
+            isShadowRoot(n.parentNode) &&
+            isNativeShadowDom(n.parentNode)) {
+            serializedNode.isShadow = true;
+        }
+        if (serializedNode.type === NodeType.Element &&
+            serializedNode.tagName === 'iframe') {
+            onceIframeLoaded(n, function () {
+                var iframeDoc = n.contentDocument;
+                if (iframeDoc && onIframeLoad) {
+                    var serializedIframeNode = serializeNodeWithId(iframeDoc, {
+                        doc: iframeDoc,
+                        mirror: mirror,
+                        blockClass: blockClass,
+                        blockSelector: blockSelector,
+                        maskTextClass: maskTextClass,
+                        maskTextSelector: maskTextSelector,
+                        skipChild: false,
+                        inlineStylesheet: inlineStylesheet,
+                        maskInputOptions: maskInputOptions,
+                        maskTextFn: maskTextFn,
+                        maskInputFn: maskInputFn,
+                        slimDOMOptions: slimDOMOptions,
+                        dataURLOptions: dataURLOptions,
+                        inlineImages: inlineImages,
+                        recordCanvas: recordCanvas,
+                        preserveWhiteSpace: preserveWhiteSpace,
+                        onSerialize: onSerialize,
+                        onIframeLoad: onIframeLoad,
+                        iframeLoadTimeout: iframeLoadTimeout,
+                        onStylesheetLoad: onStylesheetLoad,
+                        stylesheetLoadTimeout: stylesheetLoadTimeout,
+                        keepIframeSrcFn: keepIframeSrcFn
+                    });
+                    if (serializedIframeNode) {
+                        onIframeLoad(n, serializedIframeNode);
+                    }
+                }
+            }, iframeLoadTimeout);
+        }
+        if (serializedNode.type === NodeType.Element &&
+            serializedNode.tagName === 'link' &&
+            serializedNode.attributes.rel === 'stylesheet') {
+            onceStylesheetLoaded(n, function () {
+                if (onStylesheetLoad) {
+                    var serializedLinkNode = serializeNodeWithId(n, {
+                        doc: doc,
+                        mirror: mirror,
+                        blockClass: blockClass,
+                        blockSelector: blockSelector,
+                        maskTextClass: maskTextClass,
+                        maskTextSelector: maskTextSelector,
+                        skipChild: false,
+                        inlineStylesheet: inlineStylesheet,
+                        maskInputOptions: maskInputOptions,
+                        maskTextFn: maskTextFn,
+                        maskInputFn: maskInputFn,
+                        slimDOMOptions: slimDOMOptions,
+                        dataURLOptions: dataURLOptions,
+                        inlineImages: inlineImages,
+                        recordCanvas: recordCanvas,
+                        preserveWhiteSpace: preserveWhiteSpace,
+                        onSerialize: onSerialize,
+                        onIframeLoad: onIframeLoad,
+                        iframeLoadTimeout: iframeLoadTimeout,
+                        onStylesheetLoad: onStylesheetLoad,
+                        stylesheetLoadTimeout: stylesheetLoadTimeout,
+                        keepIframeSrcFn: keepIframeSrcFn
+                    });
+                    if (serializedLinkNode) {
+                        onStylesheetLoad(n, serializedLinkNode);
+                    }
+                }
+            }, stylesheetLoadTimeout);
+        }
+        return serializedNode;
+    }
+    function snapshot(n, options) {
+        var _a = options || {}, _b = _a.mirror, mirror = _b === void 0 ? new Mirror() : _b, _c = _a.blockClass, blockClass = _c === void 0 ? 'rr-block' : _c, _d = _a.blockSelector, blockSelector = _d === void 0 ? null : _d, _e = _a.maskTextClass, maskTextClass = _e === void 0 ? 'rr-mask' : _e, _f = _a.maskTextSelector, maskTextSelector = _f === void 0 ? null : _f, _g = _a.inlineStylesheet, inlineStylesheet = _g === void 0 ? true : _g, _h = _a.inlineImages, inlineImages = _h === void 0 ? false : _h, _j = _a.recordCanvas, recordCanvas = _j === void 0 ? false : _j, _k = _a.maskAllInputs, maskAllInputs = _k === void 0 ? false : _k, maskTextFn = _a.maskTextFn, maskInputFn = _a.maskInputFn, _l = _a.slimDOM, slimDOM = _l === void 0 ? false : _l, dataURLOptions = _a.dataURLOptions, preserveWhiteSpace = _a.preserveWhiteSpace, onSerialize = _a.onSerialize, onIframeLoad = _a.onIframeLoad, iframeLoadTimeout = _a.iframeLoadTimeout, onStylesheetLoad = _a.onStylesheetLoad, stylesheetLoadTimeout = _a.stylesheetLoadTimeout, _m = _a.keepIframeSrcFn, keepIframeSrcFn = _m === void 0 ? function () { return false; } : _m;
+        var maskInputOptions = maskAllInputs === true
+            ? {
+                color: true,
+                date: true,
+                'datetime-local': true,
+                email: true,
+                month: true,
+                number: true,
+                range: true,
+                search: true,
+                tel: true,
+                text: true,
+                time: true,
+                url: true,
+                week: true,
+                textarea: true,
+                select: true,
+                password: true
+            }
+            : maskAllInputs === false
+                ? {
+                    password: true
+                }
+                : maskAllInputs;
+        var slimDOMOptions = slimDOM === true || slimDOM === 'all'
+            ?
+                {
+                    script: true,
+                    comment: true,
+                    headFavicon: true,
+                    headWhitespace: true,
+                    headMetaDescKeywords: slimDOM === 'all',
+                    headMetaSocial: true,
+                    headMetaRobots: true,
+                    headMetaHttpEquiv: true,
+                    headMetaAuthorship: true,
+                    headMetaVerification: true
+                }
+            : slimDOM === false
+                ? {}
+                : slimDOM;
+        return serializeNodeWithId(n, {
+            doc: n,
+            mirror: mirror,
+            blockClass: blockClass,
+            blockSelector: blockSelector,
+            maskTextClass: maskTextClass,
+            maskTextSelector: maskTextSelector,
+            skipChild: false,
+            inlineStylesheet: inlineStylesheet,
+            maskInputOptions: maskInputOptions,
+            maskTextFn: maskTextFn,
+            maskInputFn: maskInputFn,
+            slimDOMOptions: slimDOMOptions,
+            dataURLOptions: dataURLOptions,
+            inlineImages: inlineImages,
+            recordCanvas: recordCanvas,
+            preserveWhiteSpace: preserveWhiteSpace,
+            onSerialize: onSerialize,
+            onIframeLoad: onIframeLoad,
+            iframeLoadTimeout: iframeLoadTimeout,
+            onStylesheetLoad: onStylesheetLoad,
+            stylesheetLoadTimeout: stylesheetLoadTimeout,
+            keepIframeSrcFn: keepIframeSrcFn,
+            newlyAddedElement: false
+        });
+    }
+
+    function on(type, fn, target = document) {
+        const options = { capture: true, passive: true };
+        target.addEventListener(type, fn, options);
+        return () => target.removeEventListener(type, fn, options);
+    }
+    const DEPARTED_MIRROR_ACCESS_WARNING = 'Please stop import mirror directly. Instead of that,' +
+        '\r\n' +
+        'now you can use replayer.getMirror() to access the mirror instance of a replayer,' +
+        '\r\n' +
+        'or you can use record.mirror to access the mirror instance during recording.';
+    let _mirror = {
+        map: {},
+        getId() {
+            console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+            return -1;
+        },
+        getNode() {
+            console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+            return null;
+        },
+        removeNodeFromMap() {
+            console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+        },
+        has() {
+            console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+            return false;
+        },
+        reset() {
+            console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+        },
+    };
+    if (typeof window !== 'undefined' && window.Proxy && window.Reflect) {
+        _mirror = new Proxy(_mirror, {
+            get(target, prop, receiver) {
+                if (prop === 'map') {
+                    console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+                }
+                return Reflect.get(target, prop, receiver);
+            },
+        });
+    }
+    function throttle(func, wait, options = {}) {
+        let timeout = null;
+        let previous = 0;
+        return function (...args) {
+            const now = Date.now();
+            if (!previous && options.leading === false) {
+                previous = now;
+            }
+            const remaining = wait - (now - previous);
+            const context = this;
+            if (remaining <= 0 || remaining > wait) {
+                if (timeout) {
+                    clearTimeout(timeout);
+                    timeout = null;
+                }
+                previous = now;
+                func.apply(context, args);
+            }
+            else if (!timeout && options.trailing !== false) {
+                timeout = setTimeout(() => {
+                    previous = options.leading === false ? 0 : Date.now();
+                    timeout = null;
+                    func.apply(context, args);
+                }, remaining);
+            }
+        };
+    }
+    function hookSetter(target, key, d, isRevoked, win = window) {
+        const original = win.Object.getOwnPropertyDescriptor(target, key);
+        win.Object.defineProperty(target, key, isRevoked
+            ? d
+            : {
+                set(value) {
+                    setTimeout(() => {
+                        d.set.call(this, value);
+                    }, 0);
+                    if (original && original.set) {
+                        original.set.call(this, value);
+                    }
+                },
+            });
+        return () => hookSetter(target, key, original || {}, true);
+    }
+    function patch(source, name, replacement) {
+        try {
+            if (!(name in source)) {
+                return () => {
+                };
+            }
+            const original = source[name];
+            const wrapped = replacement(original);
+            if (typeof wrapped === 'function') {
+                wrapped.prototype = wrapped.prototype || {};
+                Object.defineProperties(wrapped, {
+                    __rrweb_original__: {
+                        enumerable: false,
+                        value: original,
+                    },
+                });
+            }
+            source[name] = wrapped;
+            return () => {
+                source[name] = original;
+            };
+        }
+        catch (_a) {
+            return () => {
+            };
+        }
+    }
+    function getWindowHeight() {
+        return (window.innerHeight ||
+            (document.documentElement && document.documentElement.clientHeight) ||
+            (document.body && document.body.clientHeight));
+    }
+    function getWindowWidth() {
+        return (window.innerWidth ||
+            (document.documentElement && document.documentElement.clientWidth) ||
+            (document.body && document.body.clientWidth));
+    }
+    function isBlocked(node, blockClass, blockSelector, checkAncestors) {
+        if (!node) {
+            return false;
+        }
+        const el = node.nodeType === node.ELEMENT_NODE
+            ? node
+            : node.parentElement;
+        if (!el)
+            return false;
+        if (typeof blockClass === 'string') {
+            if (el.classList.contains(blockClass))
+                return true;
+            if (checkAncestors && el.closest('.' + blockClass) !== null)
+                return true;
+        }
+        else {
+            if (classMatchesRegex(el, blockClass, checkAncestors))
+                return true;
+        }
+        if (blockSelector) {
+            if (node.matches(blockSelector))
+                return true;
+            if (checkAncestors && el.closest(blockSelector) !== null)
+                return true;
+        }
+        return false;
+    }
+    function isSerialized(n, mirror) {
+        return mirror.getId(n) !== -1;
+    }
+    function isIgnored(n, mirror) {
+        return mirror.getId(n) === IGNORED_NODE;
+    }
+    function isAncestorRemoved(target, mirror) {
+        if (isShadowRoot(target)) {
+            return false;
+        }
+        const id = mirror.getId(target);
+        if (!mirror.has(id)) {
+            return true;
+        }
+        if (target.parentNode &&
+            target.parentNode.nodeType === target.DOCUMENT_NODE) {
+            return false;
+        }
+        if (!target.parentNode) {
+            return true;
+        }
+        return isAncestorRemoved(target.parentNode, mirror);
+    }
+    function isTouchEvent(event) {
+        return Boolean(event.changedTouches);
+    }
+    function polyfill(win = window) {
+        if ('NodeList' in win && !win.NodeList.prototype.forEach) {
+            win.NodeList.prototype.forEach = Array.prototype
+                .forEach;
+        }
+        if ('DOMTokenList' in win && !win.DOMTokenList.prototype.forEach) {
+            win.DOMTokenList.prototype.forEach = Array.prototype
+                .forEach;
+        }
+        if (!Node.prototype.contains) {
+            Node.prototype.contains = (...args) => {
+                let node = args[0];
+                if (!(0 in args)) {
+                    throw new TypeError('1 argument is required');
+                }
+                do {
+                    if (this === node) {
+                        return true;
+                    }
+                } while ((node = node && node.parentNode));
+                return false;
+            };
+        }
+    }
+    function isSerializedIframe(n, mirror) {
+        return Boolean(n.nodeName === 'IFRAME' && mirror.getMeta(n));
+    }
+    function isSerializedStylesheet(n, mirror) {
+        return Boolean(n.nodeName === 'LINK' &&
+            n.nodeType === n.ELEMENT_NODE &&
+            n.getAttribute &&
+            n.getAttribute('rel') === 'stylesheet' &&
+            mirror.getMeta(n));
+    }
+    function hasShadowRoot(n) {
+        return Boolean(n === null || n === void 0 ? void 0 : n.shadowRoot);
+    }
+    class StyleSheetMirror {
+        constructor() {
+            this.id = 1;
+            this.styleIDMap = new WeakMap();
+            this.idStyleMap = new Map();
+        }
+        getId(stylesheet) {
+            var _a;
+            return (_a = this.styleIDMap.get(stylesheet)) !== null && _a !== void 0 ? _a : -1;
+        }
+        has(stylesheet) {
+            return this.styleIDMap.has(stylesheet);
+        }
+        add(stylesheet, id) {
+            if (this.has(stylesheet))
+                return this.getId(stylesheet);
+            let newId;
+            if (id === undefined) {
+                newId = this.id++;
+            }
+            else
+                newId = id;
+            this.styleIDMap.set(stylesheet, newId);
+            this.idStyleMap.set(newId, stylesheet);
+            return newId;
+        }
+        getStyle(id) {
+            return this.idStyleMap.get(id) || null;
+        }
+        reset() {
+            this.styleIDMap = new WeakMap();
+            this.idStyleMap = new Map();
+            this.id = 1;
+        }
+        generateId() {
+            return this.id++;
+        }
+    }
+
+    var EventType = /* @__PURE__ */ ((EventType2) => {
+      EventType2[EventType2["DomContentLoaded"] = 0] = "DomContentLoaded";
+      EventType2[EventType2["Load"] = 1] = "Load";
+      EventType2[EventType2["FullSnapshot"] = 2] = "FullSnapshot";
+      EventType2[EventType2["IncrementalSnapshot"] = 3] = "IncrementalSnapshot";
+      EventType2[EventType2["Meta"] = 4] = "Meta";
+      EventType2[EventType2["Custom"] = 5] = "Custom";
+      EventType2[EventType2["Plugin"] = 6] = "Plugin";
+      return EventType2;
+    })(EventType || {});
+    var IncrementalSource = /* @__PURE__ */ ((IncrementalSource2) => {
+      IncrementalSource2[IncrementalSource2["Mutation"] = 0] = "Mutation";
+      IncrementalSource2[IncrementalSource2["MouseMove"] = 1] = "MouseMove";
+      IncrementalSource2[IncrementalSource2["MouseInteraction"] = 2] = "MouseInteraction";
+      IncrementalSource2[IncrementalSource2["Scroll"] = 3] = "Scroll";
+      IncrementalSource2[IncrementalSource2["ViewportResize"] = 4] = "ViewportResize";
+      IncrementalSource2[IncrementalSource2["Input"] = 5] = "Input";
+      IncrementalSource2[IncrementalSource2["TouchMove"] = 6] = "TouchMove";
+      IncrementalSource2[IncrementalSource2["MediaInteraction"] = 7] = "MediaInteraction";
+      IncrementalSource2[IncrementalSource2["StyleSheetRule"] = 8] = "StyleSheetRule";
+      IncrementalSource2[IncrementalSource2["CanvasMutation"] = 9] = "CanvasMutation";
+      IncrementalSource2[IncrementalSource2["Font"] = 10] = "Font";
+      IncrementalSource2[IncrementalSource2["Log"] = 11] = "Log";
+      IncrementalSource2[IncrementalSource2["Drag"] = 12] = "Drag";
+      IncrementalSource2[IncrementalSource2["StyleDeclaration"] = 13] = "StyleDeclaration";
+      IncrementalSource2[IncrementalSource2["Selection"] = 14] = "Selection";
+      IncrementalSource2[IncrementalSource2["AdoptedStyleSheet"] = 15] = "AdoptedStyleSheet";
+      return IncrementalSource2;
+    })(IncrementalSource || {});
+    var MouseInteractions = /* @__PURE__ */ ((MouseInteractions2) => {
+      MouseInteractions2[MouseInteractions2["MouseUp"] = 0] = "MouseUp";
+      MouseInteractions2[MouseInteractions2["MouseDown"] = 1] = "MouseDown";
+      MouseInteractions2[MouseInteractions2["Click"] = 2] = "Click";
+      MouseInteractions2[MouseInteractions2["ContextMenu"] = 3] = "ContextMenu";
+      MouseInteractions2[MouseInteractions2["DblClick"] = 4] = "DblClick";
+      MouseInteractions2[MouseInteractions2["Focus"] = 5] = "Focus";
+      MouseInteractions2[MouseInteractions2["Blur"] = 6] = "Blur";
+      MouseInteractions2[MouseInteractions2["TouchStart"] = 7] = "TouchStart";
+      MouseInteractions2[MouseInteractions2["TouchMove_Departed"] = 8] = "TouchMove_Departed";
+      MouseInteractions2[MouseInteractions2["TouchEnd"] = 9] = "TouchEnd";
+      MouseInteractions2[MouseInteractions2["TouchCancel"] = 10] = "TouchCancel";
+      return MouseInteractions2;
+    })(MouseInteractions || {});
+    var CanvasContext = /* @__PURE__ */ ((CanvasContext2) => {
+      CanvasContext2[CanvasContext2["2D"] = 0] = "2D";
+      CanvasContext2[CanvasContext2["WebGL"] = 1] = "WebGL";
+      CanvasContext2[CanvasContext2["WebGL2"] = 2] = "WebGL2";
+      return CanvasContext2;
+    })(CanvasContext || {});
+
+    function isNodeInLinkedList(n) {
+        return '__ln' in n;
+    }
+    class DoubleLinkedList {
+        constructor() {
+            this.length = 0;
+            this.head = null;
+        }
+        get(position) {
+            if (position >= this.length) {
+                throw new Error('Position outside of list range');
+            }
+            let current = this.head;
+            for (let index = 0; index < position; index++) {
+                current = (current === null || current === void 0 ? void 0 : current.next) || null;
+            }
+            return current;
+        }
+        addNode(n) {
+            const node = {
+                value: n,
+                previous: null,
+                next: null,
+            };
+            n.__ln = node;
+            if (n.previousSibling && isNodeInLinkedList(n.previousSibling)) {
+                const current = n.previousSibling.__ln.next;
+                node.next = current;
+                node.previous = n.previousSibling.__ln;
+                n.previousSibling.__ln.next = node;
+                if (current) {
+                    current.previous = node;
+                }
+            }
+            else if (n.nextSibling &&
+                isNodeInLinkedList(n.nextSibling) &&
+                n.nextSibling.__ln.previous) {
+                const current = n.nextSibling.__ln.previous;
+                node.previous = current;
+                node.next = n.nextSibling.__ln;
+                n.nextSibling.__ln.previous = node;
+                if (current) {
+                    current.next = node;
+                }
+            }
+            else {
+                if (this.head) {
+                    this.head.previous = node;
+                }
+                node.next = this.head;
+                this.head = node;
+            }
+            this.length++;
+        }
+        removeNode(n) {
+            const current = n.__ln;
+            if (!this.head) {
+                return;
+            }
+            if (!current.previous) {
+                this.head = current.next;
+                if (this.head) {
+                    this.head.previous = null;
+                }
+            }
+            else {
+                current.previous.next = current.next;
+                if (current.next) {
+                    current.next.previous = current.previous;
+                }
+            }
+            if (n.__ln) {
+                delete n.__ln;
+            }
+            this.length--;
+        }
+    }
+    const moveKey = (id, parentId) => `${id}@${parentId}`;
+    class MutationBuffer {
+        constructor() {
+            this.frozen = false;
+            this.locked = false;
+            this.texts = [];
+            this.attributes = [];
+            this.removes = [];
+            this.mapRemoves = [];
+            this.movedMap = {};
+            this.addedSet = new Set();
+            this.movedSet = new Set();
+            this.droppedSet = new Set();
+            this.processMutations = (mutations) => {
+                mutations.forEach(this.processMutation);
+                this.emit();
+            };
+            this.emit = () => {
+                if (this.frozen || this.locked) {
+                    return;
+                }
+                const adds = [];
+                const addList = new DoubleLinkedList();
+                const getNextId = (n) => {
+                    let ns = n;
+                    let nextId = IGNORED_NODE;
+                    while (nextId === IGNORED_NODE) {
+                        ns = ns && ns.nextSibling;
+                        nextId = ns && this.mirror.getId(ns);
+                    }
+                    return nextId;
+                };
+                const pushAdd = (n) => {
+                    var _a, _b, _c, _d;
+                    let shadowHost = null;
+                    if (((_b = (_a = n.getRootNode) === null || _a === void 0 ? void 0 : _a.call(n)) === null || _b === void 0 ? void 0 : _b.nodeType) === Node.DOCUMENT_FRAGMENT_NODE &&
+                        n.getRootNode().host)
+                        shadowHost = n.getRootNode().host;
+                    let rootShadowHost = shadowHost;
+                    while (((_d = (_c = rootShadowHost === null || rootShadowHost === void 0 ? void 0 : rootShadowHost.getRootNode) === null || _c === void 0 ? void 0 : _c.call(rootShadowHost)) === null || _d === void 0 ? void 0 : _d.nodeType) ===
+                        Node.DOCUMENT_FRAGMENT_NODE &&
+                        rootShadowHost.getRootNode().host)
+                        rootShadowHost = rootShadowHost.getRootNode().host;
+                    const notInDoc = !this.doc.contains(n) &&
+                        (!rootShadowHost || !this.doc.contains(rootShadowHost));
+                    if (!n.parentNode || notInDoc) {
+                        return;
+                    }
+                    const parentId = isShadowRoot(n.parentNode)
+                        ? this.mirror.getId(shadowHost)
+                        : this.mirror.getId(n.parentNode);
+                    const nextId = getNextId(n);
+                    if (parentId === -1 || nextId === -1) {
+                        return addList.addNode(n);
+                    }
+                    const sn = serializeNodeWithId(n, {
+                        doc: this.doc,
+                        mirror: this.mirror,
+                        blockClass: this.blockClass,
+                        blockSelector: this.blockSelector,
+                        maskTextClass: this.maskTextClass,
+                        maskTextSelector: this.maskTextSelector,
+                        skipChild: true,
+                        newlyAddedElement: true,
+                        inlineStylesheet: this.inlineStylesheet,
+                        maskInputOptions: this.maskInputOptions,
+                        maskTextFn: this.maskTextFn,
+                        maskInputFn: this.maskInputFn,
+                        slimDOMOptions: this.slimDOMOptions,
+                        dataURLOptions: this.dataURLOptions,
+                        recordCanvas: this.recordCanvas,
+                        inlineImages: this.inlineImages,
+                        onSerialize: (currentN) => {
+                            if (isSerializedIframe(currentN, this.mirror)) {
+                                this.iframeManager.addIframe(currentN);
+                            }
+                            if (isSerializedStylesheet(currentN, this.mirror)) {
+                                this.stylesheetManager.trackLinkElement(currentN);
+                            }
+                            if (hasShadowRoot(n)) {
+                                this.shadowDomManager.addShadowRoot(n.shadowRoot, this.doc);
+                            }
+                        },
+                        onIframeLoad: (iframe, childSn) => {
+                            this.iframeManager.attachIframe(iframe, childSn);
+                            this.shadowDomManager.observeAttachShadow(iframe);
+                        },
+                        onStylesheetLoad: (link, childSn) => {
+                            this.stylesheetManager.attachLinkElement(link, childSn);
+                        },
+                    });
+                    if (sn) {
+                        adds.push({
+                            parentId,
+                            nextId,
+                            node: sn,
+                        });
+                    }
+                };
+                while (this.mapRemoves.length) {
+                    this.mirror.removeNodeFromMap(this.mapRemoves.shift());
+                }
+                for (const n of Array.from(this.movedSet.values())) {
+                    if (isParentRemoved(this.removes, n, this.mirror) &&
+                        !this.movedSet.has(n.parentNode)) {
+                        continue;
+                    }
+                    pushAdd(n);
+                }
+                for (const n of Array.from(this.addedSet.values())) {
+                    if (!isAncestorInSet(this.droppedSet, n) &&
+                        !isParentRemoved(this.removes, n, this.mirror)) {
+                        pushAdd(n);
+                    }
+                    else if (isAncestorInSet(this.movedSet, n)) {
+                        pushAdd(n);
+                    }
+                    else {
+                        this.droppedSet.add(n);
+                    }
+                }
+                let candidate = null;
+                while (addList.length) {
+                    let node = null;
+                    if (candidate) {
+                        const parentId = this.mirror.getId(candidate.value.parentNode);
+                        const nextId = getNextId(candidate.value);
+                        if (parentId !== -1 && nextId !== -1) {
+                            node = candidate;
+                        }
+                    }
+                    if (!node) {
+                        for (let index = addList.length - 1; index >= 0; index--) {
+                            const _node = addList.get(index);
+                            if (_node) {
+                                const parentId = this.mirror.getId(_node.value.parentNode);
+                                const nextId = getNextId(_node.value);
+                                if (nextId === -1)
+                                    continue;
+                                else if (parentId !== -1) {
+                                    node = _node;
+                                    break;
+                                }
+                                else {
+                                    const unhandledNode = _node.value;
+                                    if (unhandledNode.parentNode &&
+                                        unhandledNode.parentNode.nodeType ===
+                                            Node.DOCUMENT_FRAGMENT_NODE) {
+                                        const shadowHost = unhandledNode.parentNode
+                                            .host;
+                                        const parentId = this.mirror.getId(shadowHost);
+                                        if (parentId !== -1) {
+                                            node = _node;
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (!node) {
+                        while (addList.head) {
+                            addList.removeNode(addList.head.value);
+                        }
+                        break;
+                    }
+                    candidate = node.previous;
+                    addList.removeNode(node.value);
+                    pushAdd(node.value);
+                }
+                const payload = {
+                    texts: this.texts
+                        .map((text) => ({
+                        id: this.mirror.getId(text.node),
+                        value: text.value,
+                    }))
+                        .filter((text) => this.mirror.has(text.id)),
+                    attributes: this.attributes
+                        .map((attribute) => ({
+                        id: this.mirror.getId(attribute.node),
+                        attributes: attribute.attributes,
+                    }))
+                        .filter((attribute) => this.mirror.has(attribute.id)),
+                    removes: this.removes,
+                    adds,
+                };
+                if (!payload.texts.length &&
+                    !payload.attributes.length &&
+                    !payload.removes.length &&
+                    !payload.adds.length) {
+                    return;
+                }
+                this.texts = [];
+                this.attributes = [];
+                this.removes = [];
+                this.addedSet = new Set();
+                this.movedSet = new Set();
+                this.droppedSet = new Set();
+                this.movedMap = {};
+                this.mutationCb(payload);
+            };
+            this.processMutation = (m) => {
+                if (isIgnored(m.target, this.mirror)) {
+                    return;
+                }
+                switch (m.type) {
+                    case 'characterData': {
+                        const value = m.target.textContent;
+                        if (!isBlocked(m.target, this.blockClass, this.blockSelector, false) &&
+                            value !== m.oldValue) {
+                            this.texts.push({
+                                value: needMaskingText(m.target, this.maskTextClass, this.maskTextSelector) && value
+                                    ? this.maskTextFn
+                                        ? this.maskTextFn(value)
+                                        : value.replace(/[\S]/g, '*')
+                                    : value,
+                                node: m.target,
+                            });
+                        }
+                        break;
+                    }
+                    case 'attributes': {
+                        const target = m.target;
+                        let value = m.target.getAttribute(m.attributeName);
+                        if (m.attributeName === 'value') {
+                            value = maskInputValue({
+                                maskInputOptions: this.maskInputOptions,
+                                tagName: m.target.tagName,
+                                type: m.target.getAttribute('type'),
+                                value,
+                                maskInputFn: this.maskInputFn,
+                            });
+                        }
+                        if (isBlocked(m.target, this.blockClass, this.blockSelector, false) ||
+                            value === m.oldValue) {
+                            return;
+                        }
+                        let item = this.attributes.find((a) => a.node === m.target);
+                        if (target.tagName === 'IFRAME' &&
+                            m.attributeName === 'src' &&
+                            !this.keepIframeSrcFn(value)) {
+                            if (!target.contentDocument) {
+                                m.attributeName = 'rr_src';
+                            }
+                            else {
+                                return;
+                            }
+                        }
+                        if (!item) {
+                            item = {
+                                node: m.target,
+                                attributes: {},
+                            };
+                            this.attributes.push(item);
+                        }
+                        if (m.attributeName === 'style') {
+                            const old = this.doc.createElement('span');
+                            if (m.oldValue) {
+                                old.setAttribute('style', m.oldValue);
+                            }
+                            if (item.attributes.style === undefined ||
+                                item.attributes.style === null) {
+                                item.attributes.style = {};
+                            }
+                            const styleObj = item.attributes.style;
+                            for (const pname of Array.from(target.style)) {
+                                const newValue = target.style.getPropertyValue(pname);
+                                const newPriority = target.style.getPropertyPriority(pname);
+                                if (newValue !== old.style.getPropertyValue(pname) ||
+                                    newPriority !== old.style.getPropertyPriority(pname)) {
+                                    if (newPriority === '') {
+                                        styleObj[pname] = newValue;
+                                    }
+                                    else {
+                                        styleObj[pname] = [newValue, newPriority];
+                                    }
+                                }
+                            }
+                            for (const pname of Array.from(old.style)) {
+                                if (target.style.getPropertyValue(pname) === '') {
+                                    styleObj[pname] = false;
+                                }
+                            }
+                        }
+                        else {
+                            item.attributes[m.attributeName] = transformAttribute(this.doc, target.tagName, m.attributeName, value);
+                        }
+                        break;
+                    }
+                    case 'childList': {
+                        if (isBlocked(m.target, this.blockClass, this.blockSelector, true))
+                            return;
+                        m.addedNodes.forEach((n) => this.genAdds(n, m.target));
+                        m.removedNodes.forEach((n) => {
+                            const nodeId = this.mirror.getId(n);
+                            const parentId = isShadowRoot(m.target)
+                                ? this.mirror.getId(m.target.host)
+                                : this.mirror.getId(m.target);
+                            if (isBlocked(m.target, this.blockClass, this.blockSelector, false) ||
+                                isIgnored(n, this.mirror) ||
+                                !isSerialized(n, this.mirror)) {
+                                return;
+                            }
+                            if (this.addedSet.has(n)) {
+                                deepDelete(this.addedSet, n);
+                                this.droppedSet.add(n);
+                            }
+                            else if (this.addedSet.has(m.target) && nodeId === -1) ;
+                            else if (isAncestorRemoved(m.target, this.mirror)) ;
+                            else if (this.movedSet.has(n) &&
+                                this.movedMap[moveKey(nodeId, parentId)]) {
+                                deepDelete(this.movedSet, n);
+                            }
+                            else {
+                                this.removes.push({
+                                    parentId,
+                                    id: nodeId,
+                                    isShadow: isShadowRoot(m.target) && isNativeShadowDom(m.target)
+                                        ? true
+                                        : undefined,
+                                });
+                            }
+                            this.mapRemoves.push(n);
+                        });
+                        break;
+                    }
+                }
+            };
+            this.genAdds = (n, target) => {
+                if (this.mirror.hasNode(n)) {
+                    if (isIgnored(n, this.mirror)) {
+                        return;
+                    }
+                    this.movedSet.add(n);
+                    let targetId = null;
+                    if (target && this.mirror.hasNode(target)) {
+                        targetId = this.mirror.getId(target);
+                    }
+                    if (targetId && targetId !== -1) {
+                        this.movedMap[moveKey(this.mirror.getId(n), targetId)] = true;
+                    }
+                }
+                else {
+                    this.addedSet.add(n);
+                    this.droppedSet.delete(n);
+                }
+                if (!isBlocked(n, this.blockClass, this.blockSelector, false))
+                    n.childNodes.forEach((childN) => this.genAdds(childN));
+            };
+        }
+        init(options) {
+            [
+                'mutationCb',
+                'blockClass',
+                'blockSelector',
+                'maskTextClass',
+                'maskTextSelector',
+                'inlineStylesheet',
+                'maskInputOptions',
+                'maskTextFn',
+                'maskInputFn',
+                'keepIframeSrcFn',
+                'recordCanvas',
+                'inlineImages',
+                'slimDOMOptions',
+                'dataURLOptions',
+                'doc',
+                'mirror',
+                'iframeManager',
+                'stylesheetManager',
+                'shadowDomManager',
+                'canvasManager',
+            ].forEach((key) => {
+                this[key] = options[key];
+            });
+        }
+        freeze() {
+            this.frozen = true;
+            this.canvasManager.freeze();
+        }
+        unfreeze() {
+            this.frozen = false;
+            this.canvasManager.unfreeze();
+            this.emit();
+        }
+        isFrozen() {
+            return this.frozen;
+        }
+        lock() {
+            this.locked = true;
+            this.canvasManager.lock();
+        }
+        unlock() {
+            this.locked = false;
+            this.canvasManager.unlock();
+            this.emit();
+        }
+        reset() {
+            this.shadowDomManager.reset();
+            this.canvasManager.reset();
+        }
+    }
+    function deepDelete(addsSet, n) {
+        addsSet.delete(n);
+        n.childNodes.forEach((childN) => deepDelete(addsSet, childN));
+    }
+    function isParentRemoved(removes, n, mirror) {
+        if (removes.length === 0)
+            return false;
+        return _isParentRemoved(removes, n, mirror);
+    }
+    function _isParentRemoved(removes, n, mirror) {
+        const { parentNode } = n;
+        if (!parentNode) {
+            return false;
+        }
+        const parentId = mirror.getId(parentNode);
+        if (removes.some((r) => r.id === parentId)) {
+            return true;
+        }
+        return _isParentRemoved(removes, parentNode, mirror);
+    }
+    function isAncestorInSet(set, n) {
+        if (set.size === 0)
+            return false;
+        return _isAncestorInSet(set, n);
+    }
+    function _isAncestorInSet(set, n) {
+        const { parentNode } = n;
+        if (!parentNode) {
+            return false;
+        }
+        if (set.has(parentNode)) {
+            return true;
+        }
+        return _isAncestorInSet(set, parentNode);
+    }
+
+    const mutationBuffers = [];
+    const isCSSGroupingRuleSupported = typeof CSSGroupingRule !== 'undefined';
+    const isCSSMediaRuleSupported = typeof CSSMediaRule !== 'undefined';
+    const isCSSSupportsRuleSupported = typeof CSSSupportsRule !== 'undefined';
+    const isCSSConditionRuleSupported = typeof CSSConditionRule !== 'undefined';
+    function getEventTarget(event) {
+        try {
+            if ('composedPath' in event) {
+                const path = event.composedPath();
+                if (path.length) {
+                    return path[0];
+                }
+            }
+            else if ('path' in event && event.path.length) {
+                return event.path[0];
+            }
+            return event.target;
+        }
+        catch (_a) {
+            return event.target;
+        }
+    }
+    function initMutationObserver(options, rootEl) {
+        var _a, _b;
+        const mutationBuffer = new MutationBuffer();
+        mutationBuffers.push(mutationBuffer);
+        mutationBuffer.init(options);
+        let mutationObserverCtor = window.MutationObserver ||
+            window.__rrMutationObserver;
+        const angularZoneSymbol = (_b = (_a = window === null || window === void 0 ? void 0 : window.Zone) === null || _a === void 0 ? void 0 : _a.__symbol__) === null || _b === void 0 ? void 0 : _b.call(_a, 'MutationObserver');
+        if (angularZoneSymbol &&
+            window[angularZoneSymbol]) {
+            mutationObserverCtor = window[angularZoneSymbol];
+        }
+        const observer = new mutationObserverCtor(mutationBuffer.processMutations.bind(mutationBuffer));
+        observer.observe(rootEl, {
+            attributes: true,
+            attributeOldValue: true,
+            characterData: true,
+            characterDataOldValue: true,
+            childList: true,
+            subtree: true,
+        });
+        return observer;
+    }
+    function initMoveObserver({ mousemoveCb, sampling, doc, mirror, }) {
+        if (sampling.mousemove === false) {
+            return () => {
+            };
+        }
+        const threshold = typeof sampling.mousemove === 'number' ? sampling.mousemove : 50;
+        const callbackThreshold = typeof sampling.mousemoveCallback === 'number'
+            ? sampling.mousemoveCallback
+            : 500;
+        let positions = [];
+        let timeBaseline;
+        const wrappedCb = throttle((source) => {
+            const totalOffset = Date.now() - timeBaseline;
+            mousemoveCb(positions.map((p) => {
+                p.timeOffset -= totalOffset;
+                return p;
+            }), source);
+            positions = [];
+            timeBaseline = null;
+        }, callbackThreshold);
+        const updatePosition = throttle((evt) => {
+            const target = getEventTarget(evt);
+            const { clientX, clientY } = isTouchEvent(evt)
+                ? evt.changedTouches[0]
+                : evt;
+            if (!timeBaseline) {
+                timeBaseline = Date.now();
+            }
+            positions.push({
+                x: clientX,
+                y: clientY,
+                id: mirror.getId(target),
+                timeOffset: Date.now() - timeBaseline,
+            });
+            wrappedCb(typeof DragEvent !== 'undefined' && evt instanceof DragEvent
+                ? IncrementalSource.Drag
+                : evt instanceof MouseEvent
+                    ? IncrementalSource.MouseMove
+                    : IncrementalSource.TouchMove);
+        }, threshold, {
+            trailing: false,
+        });
+        const handlers = [
+            on('mousemove', updatePosition, doc),
+            on('touchmove', updatePosition, doc),
+            on('drag', updatePosition, doc),
+        ];
+        return () => {
+            handlers.forEach((h) => h());
+        };
+    }
+    function initMouseInteractionObserver({ mouseInteractionCb, doc, mirror, blockClass, blockSelector, sampling, }) {
+        if (sampling.mouseInteraction === false) {
+            return () => {
+            };
+        }
+        const disableMap = sampling.mouseInteraction === true ||
+            sampling.mouseInteraction === undefined
+            ? {}
+            : sampling.mouseInteraction;
+        const handlers = [];
+        const getHandler = (eventKey) => {
+            return (event) => {
+                const target = getEventTarget(event);
+                if (isBlocked(target, blockClass, blockSelector, true)) {
+                    return;
+                }
+                const e = isTouchEvent(event) ? event.changedTouches[0] : event;
+                if (!e) {
+                    return;
+                }
+                const id = mirror.getId(target);
+                const { clientX, clientY } = e;
+                mouseInteractionCb({
+                    type: MouseInteractions[eventKey],
+                    id,
+                    x: clientX,
+                    y: clientY,
+                });
+            };
+        };
+        Object.keys(MouseInteractions)
+            .filter((key) => Number.isNaN(Number(key)) &&
+            !key.endsWith('_Departed') &&
+            disableMap[key] !== false)
+            .forEach((eventKey) => {
+            const eventName = eventKey.toLowerCase();
+            const handler = getHandler(eventKey);
+            handlers.push(on(eventName, handler, doc));
+        });
+        return () => {
+            handlers.forEach((h) => h());
+        };
+    }
+    function initScrollObserver({ scrollCb, doc, mirror, blockClass, blockSelector, sampling, }) {
+        const updatePosition = throttle((evt) => {
+            const target = getEventTarget(evt);
+            if (!target || isBlocked(target, blockClass, blockSelector, true)) {
+                return;
+            }
+            const id = mirror.getId(target);
+            if (target === doc) {
+                const scrollEl = (doc.scrollingElement || doc.documentElement);
+                scrollCb({
+                    id,
+                    x: scrollEl.scrollLeft,
+                    y: scrollEl.scrollTop,
+                });
+            }
+            else {
+                scrollCb({
+                    id,
+                    x: target.scrollLeft,
+                    y: target.scrollTop,
+                });
+            }
+        }, sampling.scroll || 100);
+        return on('scroll', updatePosition, doc);
+    }
+    function initViewportResizeObserver({ viewportResizeCb, }) {
+        let lastH = -1;
+        let lastW = -1;
+        const updateDimension = throttle(() => {
+            const height = getWindowHeight();
+            const width = getWindowWidth();
+            if (lastH !== height || lastW !== width) {
+                viewportResizeCb({
+                    width: Number(width),
+                    height: Number(height),
+                });
+                lastH = height;
+                lastW = width;
+            }
+        }, 200);
+        return on('resize', updateDimension, window);
+    }
+    function wrapEventWithUserTriggeredFlag(v, enable) {
+        const value = Object.assign({}, v);
+        if (!enable)
+            delete value.userTriggered;
+        return value;
+    }
+    const INPUT_TAGS = ['INPUT', 'TEXTAREA', 'SELECT'];
+    const lastInputValueMap = new WeakMap();
+    function initInputObserver({ inputCb, doc, mirror, blockClass, blockSelector, ignoreClass, maskInputOptions, maskInputFn, sampling, userTriggeredOnInput, }) {
+        function eventHandler(event) {
+            let target = getEventTarget(event);
+            const userTriggered = event.isTrusted;
+            if (target && target.tagName === 'OPTION')
+                target = target.parentElement;
+            if (!target ||
+                !target.tagName ||
+                INPUT_TAGS.indexOf(target.tagName) < 0 ||
+                isBlocked(target, blockClass, blockSelector, true)) {
+                return;
+            }
+            const type = target.type;
+            if (target.classList.contains(ignoreClass)) {
+                return;
+            }
+            let text = target.value;
+            let isChecked = false;
+            if (type === 'radio' || type === 'checkbox') {
+                isChecked = target.checked;
+            }
+            else if (maskInputOptions[target.tagName.toLowerCase()] ||
+                maskInputOptions[type]) {
+                text = maskInputValue({
+                    maskInputOptions,
+                    tagName: target.tagName,
+                    type,
+                    value: text,
+                    maskInputFn,
+                });
+            }
+            cbWithDedup(target, wrapEventWithUserTriggeredFlag({ text, isChecked, userTriggered }, userTriggeredOnInput));
+            const name = target.name;
+            if (type === 'radio' && name && isChecked) {
+                doc
+                    .querySelectorAll(`input[type="radio"][name="${name}"]`)
+                    .forEach((el) => {
+                    if (el !== target) {
+                        cbWithDedup(el, wrapEventWithUserTriggeredFlag({
+                            text: el.value,
+                            isChecked: !isChecked,
+                            userTriggered: false,
+                        }, userTriggeredOnInput));
+                    }
+                });
+            }
+        }
+        function cbWithDedup(target, v) {
+            const lastInputValue = lastInputValueMap.get(target);
+            if (!lastInputValue ||
+                lastInputValue.text !== v.text ||
+                lastInputValue.isChecked !== v.isChecked) {
+                lastInputValueMap.set(target, v);
+                const id = mirror.getId(target);
+                inputCb(Object.assign(Object.assign({}, v), { id }));
+            }
+        }
+        const events = sampling.input === 'last' ? ['change'] : ['input', 'change'];
+        const handlers = events.map((eventName) => on(eventName, eventHandler, doc));
+        const currentWindow = doc.defaultView;
+        if (!currentWindow) {
+            return () => {
+                handlers.forEach((h) => h());
+            };
+        }
+        const propertyDescriptor = currentWindow.Object.getOwnPropertyDescriptor(currentWindow.HTMLInputElement.prototype, 'value');
+        const hookProperties = [
+            [currentWindow.HTMLInputElement.prototype, 'value'],
+            [currentWindow.HTMLInputElement.prototype, 'checked'],
+            [currentWindow.HTMLSelectElement.prototype, 'value'],
+            [currentWindow.HTMLTextAreaElement.prototype, 'value'],
+            [currentWindow.HTMLSelectElement.prototype, 'selectedIndex'],
+            [currentWindow.HTMLOptionElement.prototype, 'selected'],
+        ];
+        if (propertyDescriptor && propertyDescriptor.set) {
+            handlers.push(...hookProperties.map((p) => hookSetter(p[0], p[1], {
+                set() {
+                    eventHandler({ target: this });
+                },
+            }, false, currentWindow)));
+        }
+        return () => {
+            handlers.forEach((h) => h());
+        };
+    }
+    function getNestedCSSRulePositions(rule) {
+        const positions = [];
+        function recurse(childRule, pos) {
+            if ((isCSSGroupingRuleSupported &&
+                childRule.parentRule instanceof CSSGroupingRule) ||
+                (isCSSMediaRuleSupported &&
+                    childRule.parentRule instanceof CSSMediaRule) ||
+                (isCSSSupportsRuleSupported &&
+                    childRule.parentRule instanceof CSSSupportsRule) ||
+                (isCSSConditionRuleSupported &&
+                    childRule.parentRule instanceof CSSConditionRule)) {
+                const rules = Array.from(childRule.parentRule.cssRules);
+                const index = rules.indexOf(childRule);
+                pos.unshift(index);
+            }
+            else if (childRule.parentStyleSheet) {
+                const rules = Array.from(childRule.parentStyleSheet.cssRules);
+                const index = rules.indexOf(childRule);
+                pos.unshift(index);
+            }
+            return pos;
+        }
+        return recurse(rule, positions);
+    }
+    function getIdAndStyleId(sheet, mirror, styleMirror) {
+        let id, styleId;
+        if (!sheet)
+            return {};
+        if (sheet.ownerNode)
+            id = mirror.getId(sheet.ownerNode);
+        else
+            styleId = styleMirror.getId(sheet);
+        return {
+            styleId,
+            id,
+        };
+    }
+    function initStyleSheetObserver({ styleSheetRuleCb, mirror, stylesheetManager }, { win }) {
+        const insertRule = win.CSSStyleSheet.prototype.insertRule;
+        win.CSSStyleSheet.prototype.insertRule = function (rule, index) {
+            const { id, styleId } = getIdAndStyleId(this, mirror, stylesheetManager.styleMirror);
+            if ((id && id !== -1) || (styleId && styleId !== -1)) {
+                styleSheetRuleCb({
+                    id,
+                    styleId,
+                    adds: [{ rule, index }],
+                });
+            }
+            return insertRule.apply(this, [rule, index]);
+        };
+        const deleteRule = win.CSSStyleSheet.prototype.deleteRule;
+        win.CSSStyleSheet.prototype.deleteRule = function (index) {
+            const { id, styleId } = getIdAndStyleId(this, mirror, stylesheetManager.styleMirror);
+            if ((id && id !== -1) || (styleId && styleId !== -1)) {
+                styleSheetRuleCb({
+                    id,
+                    styleId,
+                    removes: [{ index }],
+                });
+            }
+            return deleteRule.apply(this, [index]);
+        };
+        let replace;
+        if (win.CSSStyleSheet.prototype.replace) {
+            replace = win.CSSStyleSheet.prototype.replace;
+            win.CSSStyleSheet.prototype.replace = function (text) {
+                const { id, styleId } = getIdAndStyleId(this, mirror, stylesheetManager.styleMirror);
+                if ((id && id !== -1) || (styleId && styleId !== -1)) {
+                    styleSheetRuleCb({
+                        id,
+                        styleId,
+                        replace: text,
+                    });
+                }
+                return replace.apply(this, [text]);
+            };
+        }
+        let replaceSync;
+        if (win.CSSStyleSheet.prototype.replaceSync) {
+            replaceSync = win.CSSStyleSheet.prototype.replaceSync;
+            win.CSSStyleSheet.prototype.replaceSync = function (text) {
+                const { id, styleId } = getIdAndStyleId(this, mirror, stylesheetManager.styleMirror);
+                if ((id && id !== -1) || (styleId && styleId !== -1)) {
+                    styleSheetRuleCb({
+                        id,
+                        styleId,
+                        replaceSync: text,
+                    });
+                }
+                return replaceSync.apply(this, [text]);
+            };
+        }
+        const supportedNestedCSSRuleTypes = {};
+        if (isCSSGroupingRuleSupported) {
+            supportedNestedCSSRuleTypes.CSSGroupingRule = win.CSSGroupingRule;
+        }
+        else {
+            if (isCSSMediaRuleSupported) {
+                supportedNestedCSSRuleTypes.CSSMediaRule = win.CSSMediaRule;
+            }
+            if (isCSSConditionRuleSupported) {
+                supportedNestedCSSRuleTypes.CSSConditionRule = win.CSSConditionRule;
+            }
+            if (isCSSSupportsRuleSupported) {
+                supportedNestedCSSRuleTypes.CSSSupportsRule = win.CSSSupportsRule;
+            }
+        }
+        const unmodifiedFunctions = {};
+        Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {
+            unmodifiedFunctions[typeKey] = {
+                insertRule: type.prototype.insertRule,
+                deleteRule: type.prototype.deleteRule,
+            };
+            type.prototype.insertRule = function (rule, index) {
+                const { id, styleId } = getIdAndStyleId(this.parentStyleSheet, mirror, stylesheetManager.styleMirror);
+                if ((id && id !== -1) || (styleId && styleId !== -1)) {
+                    styleSheetRuleCb({
+                        id,
+                        styleId,
+                        adds: [
+                            {
+                                rule,
+                                index: [
+                                    ...getNestedCSSRulePositions(this),
+                                    index || 0,
+                                ],
+                            },
+                        ],
+                    });
+                }
+                return unmodifiedFunctions[typeKey].insertRule.apply(this, [rule, index]);
+            };
+            type.prototype.deleteRule = function (index) {
+                const { id, styleId } = getIdAndStyleId(this.parentStyleSheet, mirror, stylesheetManager.styleMirror);
+                if ((id && id !== -1) || (styleId && styleId !== -1)) {
+                    styleSheetRuleCb({
+                        id,
+                        styleId,
+                        removes: [
+                            { index: [...getNestedCSSRulePositions(this), index] },
+                        ],
+                    });
+                }
+                return unmodifiedFunctions[typeKey].deleteRule.apply(this, [index]);
+            };
+        });
+        return () => {
+            win.CSSStyleSheet.prototype.insertRule = insertRule;
+            win.CSSStyleSheet.prototype.deleteRule = deleteRule;
+            replace && (win.CSSStyleSheet.prototype.replace = replace);
+            replaceSync && (win.CSSStyleSheet.prototype.replaceSync = replaceSync);
+            Object.entries(supportedNestedCSSRuleTypes).forEach(([typeKey, type]) => {
+                type.prototype.insertRule = unmodifiedFunctions[typeKey].insertRule;
+                type.prototype.deleteRule = unmodifiedFunctions[typeKey].deleteRule;
+            });
+        };
+    }
+    function initAdoptedStyleSheetObserver({ mirror, stylesheetManager, }, host) {
+        var _a, _b, _c;
+        let hostId = null;
+        if (host.nodeName === '#document')
+            hostId = mirror.getId(host);
+        else
+            hostId = mirror.getId(host.host);
+        const patchTarget = host.nodeName === '#document'
+            ? (_a = host.defaultView) === null || _a === void 0 ? void 0 : _a.Document
+            : (_c = (_b = host.ownerDocument) === null || _b === void 0 ? void 0 : _b.defaultView) === null || _c === void 0 ? void 0 : _c.ShadowRoot;
+        const originalPropertyDescriptor = Object.getOwnPropertyDescriptor(patchTarget === null || patchTarget === void 0 ? void 0 : patchTarget.prototype, 'adoptedStyleSheets');
+        if (hostId === null ||
+            hostId === -1 ||
+            !patchTarget ||
+            !originalPropertyDescriptor)
+            return () => {
+            };
+        Object.defineProperty(host, 'adoptedStyleSheets', {
+            configurable: originalPropertyDescriptor.configurable,
+            enumerable: originalPropertyDescriptor.enumerable,
+            get() {
+                var _a;
+                return (_a = originalPropertyDescriptor.get) === null || _a === void 0 ? void 0 : _a.call(this);
+            },
+            set(sheets) {
+                var _a;
+                const result = (_a = originalPropertyDescriptor.set) === null || _a === void 0 ? void 0 : _a.call(this, sheets);
+                if (hostId !== null && hostId !== -1) {
+                    try {
+                        stylesheetManager.adoptStyleSheets(sheets, hostId);
+                    }
+                    catch (e) {
+                    }
+                }
+                return result;
+            },
+        });
+        return () => {
+            Object.defineProperty(host, 'adoptedStyleSheets', {
+                configurable: originalPropertyDescriptor.configurable,
+                enumerable: originalPropertyDescriptor.enumerable,
+                get: originalPropertyDescriptor.get,
+                set: originalPropertyDescriptor.set,
+            });
+        };
+    }
+    function initStyleDeclarationObserver({ styleDeclarationCb, mirror, ignoreCSSAttributes, stylesheetManager, }, { win }) {
+        const setProperty = win.CSSStyleDeclaration.prototype.setProperty;
+        win.CSSStyleDeclaration.prototype.setProperty = function (property, value, priority) {
+            var _a;
+            if (ignoreCSSAttributes.has(property)) {
+                return setProperty.apply(this, [property, value, priority]);
+            }
+            const { id, styleId } = getIdAndStyleId((_a = this.parentRule) === null || _a === void 0 ? void 0 : _a.parentStyleSheet, mirror, stylesheetManager.styleMirror);
+            if ((id && id !== -1) || (styleId && styleId !== -1)) {
+                styleDeclarationCb({
+                    id,
+                    styleId,
+                    set: {
+                        property,
+                        value,
+                        priority,
+                    },
+                    index: getNestedCSSRulePositions(this.parentRule),
+                });
+            }
+            return setProperty.apply(this, [property, value, priority]);
+        };
+        const removeProperty = win.CSSStyleDeclaration.prototype.removeProperty;
+        win.CSSStyleDeclaration.prototype.removeProperty = function (property) {
+            var _a;
+            if (ignoreCSSAttributes.has(property)) {
+                return removeProperty.apply(this, [property]);
+            }
+            const { id, styleId } = getIdAndStyleId((_a = this.parentRule) === null || _a === void 0 ? void 0 : _a.parentStyleSheet, mirror, stylesheetManager.styleMirror);
+            if ((id && id !== -1) || (styleId && styleId !== -1)) {
+                styleDeclarationCb({
+                    id,
+                    styleId,
+                    remove: {
+                        property,
+                    },
+                    index: getNestedCSSRulePositions(this.parentRule),
+                });
+            }
+            return removeProperty.apply(this, [property]);
+        };
+        return () => {
+            win.CSSStyleDeclaration.prototype.setProperty = setProperty;
+            win.CSSStyleDeclaration.prototype.removeProperty = removeProperty;
+        };
+    }
+    function initMediaInteractionObserver({ mediaInteractionCb, blockClass, blockSelector, mirror, sampling, }) {
+        const handler = (type) => throttle((event) => {
+            const target = getEventTarget(event);
+            if (!target ||
+                isBlocked(target, blockClass, blockSelector, true)) {
+                return;
+            }
+            const { currentTime, volume, muted, playbackRate, } = target;
+            mediaInteractionCb({
+                type,
+                id: mirror.getId(target),
+                currentTime,
+                volume,
+                muted,
+                playbackRate,
+            });
+        }, sampling.media || 500);
+        const handlers = [
+            on('play', handler(0)),
+            on('pause', handler(1)),
+            on('seeked', handler(2)),
+            on('volumechange', handler(3)),
+            on('ratechange', handler(4)),
+        ];
+        return () => {
+            handlers.forEach((h) => h());
+        };
+    }
+    function initFontObserver({ fontCb, doc }) {
+        const win = doc.defaultView;
+        if (!win) {
+            return () => {
+            };
+        }
+        const handlers = [];
+        const fontMap = new WeakMap();
+        const originalFontFace = win.FontFace;
+        win.FontFace = function FontFace(family, source, descriptors) {
+            const fontFace = new originalFontFace(family, source, descriptors);
+            fontMap.set(fontFace, {
+                family,
+                buffer: typeof source !== 'string',
+                descriptors,
+                fontSource: typeof source === 'string'
+                    ? source
+                    : JSON.stringify(Array.from(new Uint8Array(source))),
+            });
+            return fontFace;
+        };
+        const restoreHandler = patch(doc.fonts, 'add', function (original) {
+            return function (fontFace) {
+                setTimeout(() => {
+                    const p = fontMap.get(fontFace);
+                    if (p) {
+                        fontCb(p);
+                        fontMap.delete(fontFace);
+                    }
+                }, 0);
+                return original.apply(this, [fontFace]);
+            };
+        });
+        handlers.push(() => {
+            win.FontFace = originalFontFace;
+        });
+        handlers.push(restoreHandler);
+        return () => {
+            handlers.forEach((h) => h());
+        };
+    }
+    function initSelectionObserver(param) {
+        const { doc, mirror, blockClass, blockSelector, selectionCb } = param;
+        let collapsed = true;
+        const updateSelection = () => {
+            const selection = doc.getSelection();
+            if (!selection || (collapsed && (selection === null || selection === void 0 ? void 0 : selection.isCollapsed)))
+                return;
+            collapsed = selection.isCollapsed || false;
+            const ranges = [];
+            const count = selection.rangeCount || 0;
+            for (let i = 0; i < count; i++) {
+                const range = selection.getRangeAt(i);
+                const { startContainer, startOffset, endContainer, endOffset } = range;
+                const blocked = isBlocked(startContainer, blockClass, blockSelector, true) ||
+                    isBlocked(endContainer, blockClass, blockSelector, true);
+                if (blocked)
+                    continue;
+                ranges.push({
+                    start: mirror.getId(startContainer),
+                    startOffset,
+                    end: mirror.getId(endContainer),
+                    endOffset,
+                });
+            }
+            selectionCb({ ranges });
+        };
+        updateSelection();
+        return on('selectionchange', updateSelection);
+    }
+    function mergeHooks(o, hooks) {
+        const { mutationCb, mousemoveCb, mouseInteractionCb, scrollCb, viewportResizeCb, inputCb, mediaInteractionCb, styleSheetRuleCb, styleDeclarationCb, canvasMutationCb, fontCb, selectionCb, } = o;
+        o.mutationCb = (...p) => {
+            if (hooks.mutation) {
+                hooks.mutation(...p);
+            }
+            mutationCb(...p);
+        };
+        o.mousemoveCb = (...p) => {
+            if (hooks.mousemove) {
+                hooks.mousemove(...p);
+            }
+            mousemoveCb(...p);
+        };
+        o.mouseInteractionCb = (...p) => {
+            if (hooks.mouseInteraction) {
+                hooks.mouseInteraction(...p);
+            }
+            mouseInteractionCb(...p);
+        };
+        o.scrollCb = (...p) => {
+            if (hooks.scroll) {
+                hooks.scroll(...p);
+            }
+            scrollCb(...p);
+        };
+        o.viewportResizeCb = (...p) => {
+            if (hooks.viewportResize) {
+                hooks.viewportResize(...p);
+            }
+            viewportResizeCb(...p);
+        };
+        o.inputCb = (...p) => {
+            if (hooks.input) {
+                hooks.input(...p);
+            }
+            inputCb(...p);
+        };
+        o.mediaInteractionCb = (...p) => {
+            if (hooks.mediaInteaction) {
+                hooks.mediaInteaction(...p);
+            }
+            mediaInteractionCb(...p);
+        };
+        o.styleSheetRuleCb = (...p) => {
+            if (hooks.styleSheetRule) {
+                hooks.styleSheetRule(...p);
+            }
+            styleSheetRuleCb(...p);
+        };
+        o.styleDeclarationCb = (...p) => {
+            if (hooks.styleDeclaration) {
+                hooks.styleDeclaration(...p);
+            }
+            styleDeclarationCb(...p);
+        };
+        o.canvasMutationCb = (...p) => {
+            if (hooks.canvasMutation) {
+                hooks.canvasMutation(...p);
+            }
+            canvasMutationCb(...p);
+        };
+        o.fontCb = (...p) => {
+            if (hooks.font) {
+                hooks.font(...p);
+            }
+            fontCb(...p);
+        };
+        o.selectionCb = (...p) => {
+            if (hooks.selection) {
+                hooks.selection(...p);
+            }
+            selectionCb(...p);
+        };
+    }
+    function initObservers(o, hooks = {}) {
+        const currentWindow = o.doc.defaultView;
+        if (!currentWindow) {
+            return () => {
+            };
+        }
+        mergeHooks(o, hooks);
+        const mutationObserver = initMutationObserver(o, o.doc);
+        const mousemoveHandler = initMoveObserver(o);
+        const mouseInteractionHandler = initMouseInteractionObserver(o);
+        const scrollHandler = initScrollObserver(o);
+        const viewportResizeHandler = initViewportResizeObserver(o);
+        const inputHandler = initInputObserver(o);
+        const mediaInteractionHandler = initMediaInteractionObserver(o);
+        const styleSheetObserver = initStyleSheetObserver(o, { win: currentWindow });
+        const adoptedStyleSheetObserver = initAdoptedStyleSheetObserver(o, o.doc);
+        const styleDeclarationObserver = initStyleDeclarationObserver(o, {
+            win: currentWindow,
+        });
+        const fontObserver = o.collectFonts
+            ? initFontObserver(o)
+            : () => {
+            };
+        const selectionObserver = initSelectionObserver(o);
+        const pluginHandlers = [];
+        for (const plugin of o.plugins) {
+            pluginHandlers.push(plugin.observer(plugin.callback, currentWindow, plugin.options));
+        }
+        return () => {
+            mutationBuffers.forEach((b) => b.reset());
+            mutationObserver.disconnect();
+            mousemoveHandler();
+            mouseInteractionHandler();
+            scrollHandler();
+            viewportResizeHandler();
+            inputHandler();
+            mediaInteractionHandler();
+            styleSheetObserver();
+            adoptedStyleSheetObserver();
+            styleDeclarationObserver();
+            fontObserver();
+            selectionObserver();
+            pluginHandlers.forEach((h) => h());
+        };
+    }
+
+    class CrossOriginIframeMirror {
+        constructor(generateIdFn) {
+            this.generateIdFn = generateIdFn;
+            this.iframeIdToRemoteIdMap = new WeakMap();
+            this.iframeRemoteIdToIdMap = new WeakMap();
+        }
+        getId(iframe, remoteId, idToRemoteMap, remoteToIdMap) {
+            const idToRemoteIdMap = idToRemoteMap || this.getIdToRemoteIdMap(iframe);
+            const remoteIdToIdMap = remoteToIdMap || this.getRemoteIdToIdMap(iframe);
+            let id = idToRemoteIdMap.get(remoteId);
+            if (!id) {
+                id = this.generateIdFn();
+                idToRemoteIdMap.set(remoteId, id);
+                remoteIdToIdMap.set(id, remoteId);
+            }
+            return id;
+        }
+        getIds(iframe, remoteId) {
+            const idToRemoteIdMap = this.getIdToRemoteIdMap(iframe);
+            const remoteIdToIdMap = this.getRemoteIdToIdMap(iframe);
+            return remoteId.map((id) => this.getId(iframe, id, idToRemoteIdMap, remoteIdToIdMap));
+        }
+        getRemoteId(iframe, id, map) {
+            const remoteIdToIdMap = map || this.getRemoteIdToIdMap(iframe);
+            if (typeof id !== 'number')
+                return id;
+            const remoteId = remoteIdToIdMap.get(id);
+            if (!remoteId)
+                return -1;
+            return remoteId;
+        }
+        getRemoteIds(iframe, ids) {
+            const remoteIdToIdMap = this.getRemoteIdToIdMap(iframe);
+            return ids.map((id) => this.getRemoteId(iframe, id, remoteIdToIdMap));
+        }
+        reset(iframe) {
+            if (!iframe) {
+                this.iframeIdToRemoteIdMap = new WeakMap();
+                this.iframeRemoteIdToIdMap = new WeakMap();
+                return;
+            }
+            this.iframeIdToRemoteIdMap.delete(iframe);
+            this.iframeRemoteIdToIdMap.delete(iframe);
+        }
+        getIdToRemoteIdMap(iframe) {
+            let idToRemoteIdMap = this.iframeIdToRemoteIdMap.get(iframe);
+            if (!idToRemoteIdMap) {
+                idToRemoteIdMap = new Map();
+                this.iframeIdToRemoteIdMap.set(iframe, idToRemoteIdMap);
+            }
+            return idToRemoteIdMap;
+        }
+        getRemoteIdToIdMap(iframe) {
+            let remoteIdToIdMap = this.iframeRemoteIdToIdMap.get(iframe);
+            if (!remoteIdToIdMap) {
+                remoteIdToIdMap = new Map();
+                this.iframeRemoteIdToIdMap.set(iframe, remoteIdToIdMap);
+            }
+            return remoteIdToIdMap;
+        }
+    }
+
+    class IframeManager {
+        constructor(options) {
+            this.iframes = new WeakMap();
+            this.crossOriginIframeMap = new WeakMap();
+            this.crossOriginIframeMirror = new CrossOriginIframeMirror(genId);
+            this.mutationCb = options.mutationCb;
+            this.wrappedEmit = options.wrappedEmit;
+            this.stylesheetManager = options.stylesheetManager;
+            this.recordCrossOriginIframes = options.recordCrossOriginIframes;
+            this.crossOriginIframeStyleMirror = new CrossOriginIframeMirror(this.stylesheetManager.styleMirror.generateId.bind(this.stylesheetManager.styleMirror));
+            this.mirror = options.mirror;
+            if (this.recordCrossOriginIframes) {
+                window.addEventListener('message', this.handleMessage.bind(this));
+            }
+        }
+        addIframe(iframeEl) {
+            this.iframes.set(iframeEl, true);
+            if (iframeEl.contentWindow)
+                this.crossOriginIframeMap.set(iframeEl.contentWindow, iframeEl);
+        }
+        addLoadListener(cb) {
+            this.loadListener = cb;
+        }
+        attachIframe(iframeEl, childSn) {
+            var _a;
+            this.mutationCb({
+                adds: [
+                    {
+                        parentId: this.mirror.getId(iframeEl),
+                        nextId: null,
+                        node: childSn,
+                    },
+                ],
+                removes: [],
+                texts: [],
+                attributes: [],
+                isAttachIframe: true,
+            });
+            (_a = this.loadListener) === null || _a === void 0 ? void 0 : _a.call(this, iframeEl);
+            if (iframeEl.contentDocument &&
+                iframeEl.contentDocument.adoptedStyleSheets &&
+                iframeEl.contentDocument.adoptedStyleSheets.length > 0)
+                this.stylesheetManager.adoptStyleSheets(iframeEl.contentDocument.adoptedStyleSheets, this.mirror.getId(iframeEl.contentDocument));
+        }
+        handleMessage(message) {
+            if (message.data.type === 'rrweb') {
+                const iframeSourceWindow = message.source;
+                if (!iframeSourceWindow)
+                    return;
+                const iframeEl = this.crossOriginIframeMap.get(message.source);
+                if (!iframeEl)
+                    return;
+                const transformedEvent = this.transformCrossOriginEvent(iframeEl, message.data.event);
+                if (transformedEvent)
+                    this.wrappedEmit(transformedEvent, message.data.isCheckout);
+            }
+        }
+        transformCrossOriginEvent(iframeEl, e) {
+            var _a;
+            switch (e.type) {
+                case EventType.FullSnapshot: {
+                    this.crossOriginIframeMirror.reset(iframeEl);
+                    this.crossOriginIframeStyleMirror.reset(iframeEl);
+                    this.replaceIdOnNode(e.data.node, iframeEl);
+                    return {
+                        timestamp: e.timestamp,
+                        type: EventType.IncrementalSnapshot,
+                        data: {
+                            source: IncrementalSource.Mutation,
+                            adds: [
+                                {
+                                    parentId: this.mirror.getId(iframeEl),
+                                    nextId: null,
+                                    node: e.data.node,
+                                },
+                            ],
+                            removes: [],
+                            texts: [],
+                            attributes: [],
+                            isAttachIframe: true,
+                        },
+                    };
+                }
+                case EventType.Meta:
+                case EventType.Load:
+                case EventType.DomContentLoaded: {
+                    return false;
+                }
+                case EventType.Plugin: {
+                    return e;
+                }
+                case EventType.Custom: {
+                    this.replaceIds(e.data.payload, iframeEl, ['id', 'parentId', 'previousId', 'nextId']);
+                    return e;
+                }
+                case EventType.IncrementalSnapshot: {
+                    switch (e.data.source) {
+                        case IncrementalSource.Mutation: {
+                            e.data.adds.forEach((n) => {
+                                this.replaceIds(n, iframeEl, [
+                                    'parentId',
+                                    'nextId',
+                                    'previousId',
+                                ]);
+                                this.replaceIdOnNode(n.node, iframeEl);
+                            });
+                            e.data.removes.forEach((n) => {
+                                this.replaceIds(n, iframeEl, ['parentId', 'id']);
+                            });
+                            e.data.attributes.forEach((n) => {
+                                this.replaceIds(n, iframeEl, ['id']);
+                            });
+                            e.data.texts.forEach((n) => {
+                                this.replaceIds(n, iframeEl, ['id']);
+                            });
+                            return e;
+                        }
+                        case IncrementalSource.Drag:
+                        case IncrementalSource.TouchMove:
+                        case IncrementalSource.MouseMove: {
+                            e.data.positions.forEach((p) => {
+                                this.replaceIds(p, iframeEl, ['id']);
+                            });
+                            return e;
+                        }
+                        case IncrementalSource.ViewportResize: {
+                            return false;
+                        }
+                        case IncrementalSource.MediaInteraction:
+                        case IncrementalSource.MouseInteraction:
+                        case IncrementalSource.Scroll:
+                        case IncrementalSource.CanvasMutation:
+                        case IncrementalSource.Input: {
+                            this.replaceIds(e.data, iframeEl, ['id']);
+                            return e;
+                        }
+                        case IncrementalSource.StyleSheetRule:
+                        case IncrementalSource.StyleDeclaration: {
+                            this.replaceIds(e.data, iframeEl, ['id']);
+                            this.replaceStyleIds(e.data, iframeEl, ['styleId']);
+                            return e;
+                        }
+                        case IncrementalSource.Font: {
+                            return e;
+                        }
+                        case IncrementalSource.Selection: {
+                            e.data.ranges.forEach((range) => {
+                                this.replaceIds(range, iframeEl, ['start', 'end']);
+                            });
+                            return e;
+                        }
+                        case IncrementalSource.AdoptedStyleSheet: {
+                            this.replaceIds(e.data, iframeEl, ['id']);
+                            this.replaceStyleIds(e.data, iframeEl, ['styleIds']);
+                            (_a = e.data.styles) === null || _a === void 0 ? void 0 : _a.forEach((style) => {
+                                this.replaceStyleIds(style, iframeEl, ['styleId']);
+                            });
+                            return e;
+                        }
+                    }
+                }
+            }
+        }
+        replace(iframeMirror, obj, iframeEl, keys) {
+            for (const key of keys) {
+                if (!Array.isArray(obj[key]) && typeof obj[key] !== 'number')
+                    continue;
+                if (Array.isArray(obj[key])) {
+                    obj[key] = iframeMirror.getIds(iframeEl, obj[key]);
+                }
+                else {
+                    obj[key] = iframeMirror.getId(iframeEl, obj[key]);
+                }
+            }
+            return obj;
+        }
+        replaceIds(obj, iframeEl, keys) {
+            return this.replace(this.crossOriginIframeMirror, obj, iframeEl, keys);
+        }
+        replaceStyleIds(obj, iframeEl, keys) {
+            return this.replace(this.crossOriginIframeStyleMirror, obj, iframeEl, keys);
+        }
+        replaceIdOnNode(node, iframeEl) {
+            this.replaceIds(node, iframeEl, ['id']);
+            if ('childNodes' in node) {
+                node.childNodes.forEach((child) => {
+                    this.replaceIdOnNode(child, iframeEl);
+                });
+            }
+        }
+    }
+
+    class ShadowDomManager {
+        constructor(options) {
+            this.shadowDoms = new WeakSet();
+            this.restorePatches = [];
+            this.mutationCb = options.mutationCb;
+            this.scrollCb = options.scrollCb;
+            this.bypassOptions = options.bypassOptions;
+            this.mirror = options.mirror;
+            const manager = this;
+            this.restorePatches.push(patch(Element.prototype, 'attachShadow', function (original) {
+                return function (option) {
+                    const shadowRoot = original.call(this, option);
+                    if (this.shadowRoot)
+                        manager.addShadowRoot(this.shadowRoot, this.ownerDocument);
+                    return shadowRoot;
+                };
+            }));
+        }
+        addShadowRoot(shadowRoot, doc) {
+            if (!isNativeShadowDom(shadowRoot))
+                return;
+            if (this.shadowDoms.has(shadowRoot))
+                return;
+            this.shadowDoms.add(shadowRoot);
+            initMutationObserver(Object.assign(Object.assign({}, this.bypassOptions), { doc, mutationCb: this.mutationCb, mirror: this.mirror, shadowDomManager: this }), shadowRoot);
+            initScrollObserver(Object.assign(Object.assign({}, this.bypassOptions), { scrollCb: this.scrollCb, doc: shadowRoot, mirror: this.mirror }));
+            setTimeout(() => {
+                if (shadowRoot.adoptedStyleSheets &&
+                    shadowRoot.adoptedStyleSheets.length > 0)
+                    this.bypassOptions.stylesheetManager.adoptStyleSheets(shadowRoot.adoptedStyleSheets, this.mirror.getId(shadowRoot.host));
+                initAdoptedStyleSheetObserver({
+                    mirror: this.mirror,
+                    stylesheetManager: this.bypassOptions.stylesheetManager,
+                }, shadowRoot);
+            }, 0);
+        }
+        observeAttachShadow(iframeElement) {
+            if (iframeElement.contentWindow) {
+                const manager = this;
+                this.restorePatches.push(patch(iframeElement.contentWindow.HTMLElement.prototype, 'attachShadow', function (original) {
+                    return function (option) {
+                        const shadowRoot = original.call(this, option);
+                        if (this.shadowRoot)
+                            manager.addShadowRoot(this.shadowRoot, iframeElement.contentDocument);
+                        return shadowRoot;
+                    };
+                }));
+            }
+        }
+        reset() {
+            this.restorePatches.forEach((restorePatch) => restorePatch());
+            this.shadowDoms = new WeakSet();
+        }
+    }
+
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
+    function __rest(s, e) {
+        var t = {};
+        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+        if (s != null && typeof Object.getOwnPropertySymbols === "function")
+            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                    t[p[i]] = s[p[i]];
+            }
+        return t;
+    }
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, [])).next());
+        });
+    }
+
+    /*
+     * base64-arraybuffer 1.0.1 <https://github.com/niklasvh/base64-arraybuffer>
+     * Copyright (c) 2021 Niklas von Hertzen <https://hertzen.com>
+     * Released under MIT License
+     */
+    var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+    // Use a lookup table to find the index.
+    var lookup = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);
+    for (var i$1 = 0; i$1 < chars.length; i$1++) {
+        lookup[chars.charCodeAt(i$1)] = i$1;
+    }
+    var encode = function (arraybuffer) {
+        var bytes = new Uint8Array(arraybuffer), i, len = bytes.length, base64 = '';
+        for (i = 0; i < len; i += 3) {
+            base64 += chars[bytes[i] >> 2];
+            base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];
+            base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];
+            base64 += chars[bytes[i + 2] & 63];
+        }
+        if (len % 3 === 2) {
+            base64 = base64.substring(0, base64.length - 1) + '=';
+        }
+        else if (len % 3 === 1) {
+            base64 = base64.substring(0, base64.length - 2) + '==';
+        }
+        return base64;
+    };
+
+    const canvasVarMap = new Map();
+    function variableListFor(ctx, ctor) {
+        let contextMap = canvasVarMap.get(ctx);
+        if (!contextMap) {
+            contextMap = new Map();
+            canvasVarMap.set(ctx, contextMap);
+        }
+        if (!contextMap.has(ctor)) {
+            contextMap.set(ctor, []);
+        }
+        return contextMap.get(ctor);
+    }
+    const saveWebGLVar = (value, win, ctx) => {
+        if (!value ||
+            !(isInstanceOfWebGLObject(value, win) || typeof value === 'object'))
+            return;
+        const name = value.constructor.name;
+        const list = variableListFor(ctx, name);
+        let index = list.indexOf(value);
+        if (index === -1) {
+            index = list.length;
+            list.push(value);
+        }
+        return index;
+    };
+    function serializeArg(value, win, ctx) {
+        if (value instanceof Array) {
+            return value.map((arg) => serializeArg(arg, win, ctx));
+        }
+        else if (value === null) {
+            return value;
+        }
+        else if (value instanceof Float32Array ||
+            value instanceof Float64Array ||
+            value instanceof Int32Array ||
+            value instanceof Uint32Array ||
+            value instanceof Uint8Array ||
+            value instanceof Uint16Array ||
+            value instanceof Int16Array ||
+            value instanceof Int8Array ||
+            value instanceof Uint8ClampedArray) {
+            const name = value.constructor.name;
+            return {
+                rr_type: name,
+                args: [Object.values(value)],
+            };
+        }
+        else if (value instanceof ArrayBuffer) {
+            const name = value.constructor.name;
+            const base64 = encode(value);
+            return {
+                rr_type: name,
+                base64,
+            };
+        }
+        else if (value instanceof DataView) {
+            const name = value.constructor.name;
+            return {
+                rr_type: name,
+                args: [
+                    serializeArg(value.buffer, win, ctx),
+                    value.byteOffset,
+                    value.byteLength,
+                ],
+            };
+        }
+        else if (value instanceof HTMLImageElement) {
+            const name = value.constructor.name;
+            const { src } = value;
+            return {
+                rr_type: name,
+                src,
+            };
+        }
+        else if (value instanceof HTMLCanvasElement) {
+            const name = 'HTMLImageElement';
+            const src = value.toDataURL();
+            return {
+                rr_type: name,
+                src,
+            };
+        }
+        else if (value instanceof ImageData) {
+            const name = value.constructor.name;
+            return {
+                rr_type: name,
+                args: [serializeArg(value.data, win, ctx), value.width, value.height],
+            };
+        }
+        else if (isInstanceOfWebGLObject(value, win) || typeof value === 'object') {
+            const name = value.constructor.name;
+            const index = saveWebGLVar(value, win, ctx);
+            return {
+                rr_type: name,
+                index: index,
+            };
+        }
+        return value;
+    }
+    const serializeArgs = (args, win, ctx) => {
+        return [...args].map((arg) => serializeArg(arg, win, ctx));
+    };
+    const isInstanceOfWebGLObject = (value, win) => {
+        const webGLConstructorNames = [
+            'WebGLActiveInfo',
+            'WebGLBuffer',
+            'WebGLFramebuffer',
+            'WebGLProgram',
+            'WebGLRenderbuffer',
+            'WebGLShader',
+            'WebGLShaderPrecisionFormat',
+            'WebGLTexture',
+            'WebGLUniformLocation',
+            'WebGLVertexArrayObject',
+            'WebGLVertexArrayObjectOES',
+        ];
+        const supportedWebGLConstructorNames = webGLConstructorNames.filter((name) => typeof win[name] === 'function');
+        return Boolean(supportedWebGLConstructorNames.find((name) => value instanceof win[name]));
+    };
+
+    function initCanvas2DMutationObserver(cb, win, blockClass, blockSelector) {
+        const handlers = [];
+        const props2D = Object.getOwnPropertyNames(win.CanvasRenderingContext2D.prototype);
+        for (const prop of props2D) {
+            try {
+                if (typeof win.CanvasRenderingContext2D.prototype[prop] !== 'function') {
+                    continue;
+                }
+                const restoreHandler = patch(win.CanvasRenderingContext2D.prototype, prop, function (original) {
+                    return function (...args) {
+                        if (!isBlocked(this.canvas, blockClass, blockSelector, true)) {
+                            setTimeout(() => {
+                                const recordArgs = serializeArgs([...args], win, this);
+                                cb(this.canvas, {
+                                    type: CanvasContext['2D'],
+                                    property: prop,
+                                    args: recordArgs,
+                                });
+                            }, 0);
+                        }
+                        return original.apply(this, args);
+                    };
+                });
+                handlers.push(restoreHandler);
+            }
+            catch (_a) {
+                const hookHandler = hookSetter(win.CanvasRenderingContext2D.prototype, prop, {
+                    set(v) {
+                        cb(this.canvas, {
+                            type: CanvasContext['2D'],
+                            property: prop,
+                            args: [v],
+                            setter: true,
+                        });
+                    },
+                });
+                handlers.push(hookHandler);
+            }
+        }
+        return () => {
+            handlers.forEach((h) => h());
+        };
+    }
+
+    function initCanvasContextObserver(win, blockClass, blockSelector) {
+        const handlers = [];
+        try {
+            const restoreHandler = patch(win.HTMLCanvasElement.prototype, 'getContext', function (original) {
+                return function (contextType, ...args) {
+                    if (!isBlocked(this, blockClass, blockSelector, true)) {
+                        if (!('__context' in this))
+                            this.__context = contextType;
+                    }
+                    return original.apply(this, [contextType, ...args]);
+                };
+            });
+            handlers.push(restoreHandler);
+        }
+        catch (_a) {
+            console.error('failed to patch HTMLCanvasElement.prototype.getContext');
+        }
+        return () => {
+            handlers.forEach((h) => h());
+        };
+    }
+
+    function patchGLPrototype(prototype, type, cb, blockClass, blockSelector, mirror, win) {
+        const handlers = [];
+        const props = Object.getOwnPropertyNames(prototype);
+        for (const prop of props) {
+            if ([
+                'isContextLost',
+                'canvas',
+                'drawingBufferWidth',
+                'drawingBufferHeight',
+            ].includes(prop)) {
+                continue;
+            }
+            try {
+                if (typeof prototype[prop] !== 'function') {
+                    continue;
+                }
+                const restoreHandler = patch(prototype, prop, function (original) {
+                    return function (...args) {
+                        const result = original.apply(this, args);
+                        saveWebGLVar(result, win, this);
+                        if (!isBlocked(this.canvas, blockClass, blockSelector, true)) {
+                            const recordArgs = serializeArgs([...args], win, this);
+                            const mutation = {
+                                type,
+                                property: prop,
+                                args: recordArgs,
+                            };
+                            cb(this.canvas, mutation);
+                        }
+                        return result;
+                    };
+                });
+                handlers.push(restoreHandler);
+            }
+            catch (_a) {
+                const hookHandler = hookSetter(prototype, prop, {
+                    set(v) {
+                        cb(this.canvas, {
+                            type,
+                            property: prop,
+                            args: [v],
+                            setter: true,
+                        });
+                    },
+                });
+                handlers.push(hookHandler);
+            }
+        }
+        return handlers;
+    }
+    function initCanvasWebGLMutationObserver(cb, win, blockClass, blockSelector, mirror) {
+        const handlers = [];
+        handlers.push(...patchGLPrototype(win.WebGLRenderingContext.prototype, CanvasContext.WebGL, cb, blockClass, blockSelector, mirror, win));
+        if (typeof win.WebGL2RenderingContext !== 'undefined') {
+            handlers.push(...patchGLPrototype(win.WebGL2RenderingContext.prototype, CanvasContext.WebGL2, cb, blockClass, blockSelector, mirror, win));
+        }
+        return () => {
+            handlers.forEach((h) => h());
+        };
+    }
+
+    var WorkerClass = null;
+
+    try {
+        var WorkerThreads =
+            typeof module !== 'undefined' && typeof module.require === 'function' && module.require('worker_threads') ||
+            typeof __non_webpack_require__ === 'function' && __non_webpack_require__('worker_threads') ||
+            typeof require === 'function' && require('worker_threads');
+        WorkerClass = WorkerThreads.Worker;
+    } catch(e) {} // eslint-disable-line
+
+    function decodeBase64$1(base64, enableUnicode) {
+        return Buffer.from(base64, 'base64').toString('utf8');
+    }
+
+    function createBase64WorkerFactory$2(base64, sourcemapArg, enableUnicodeArg) {
+        var source = decodeBase64$1(base64);
+        var start = source.indexOf('\n', 10) + 1;
+        var body = source.substring(start) + ('');
+        return function WorkerFactory(options) {
+            return new WorkerClass(body, Object.assign({}, options, { eval: true }));
+        };
+    }
+
+    function decodeBase64(base64, enableUnicode) {
+        var binaryString = atob(base64);
+        return binaryString;
+    }
+
+    function createURL(base64, sourcemapArg, enableUnicodeArg) {
+        var source = decodeBase64(base64);
+        var start = source.indexOf('\n', 10) + 1;
+        var body = source.substring(start) + ('');
+        var blob = new Blob([body], { type: 'application/javascript' });
+        return URL.createObjectURL(blob);
+    }
+
+    function createBase64WorkerFactory$1(base64, sourcemapArg, enableUnicodeArg) {
+        var url;
+        return function WorkerFactory(options) {
+            url = url || createURL(base64);
+            return new Worker(url, options);
+        };
+    }
+
+    var kIsNodeJS = Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
+
+    function isNodeJS() {
+        return kIsNodeJS;
+    }
+
+    function createBase64WorkerFactory(base64, sourcemapArg, enableUnicodeArg) {
+        if (isNodeJS()) {
+            return createBase64WorkerFactory$2(base64);
+        }
+        return createBase64WorkerFactory$1(base64);
+    }
+
+    var WorkerFactory = createBase64WorkerFactory('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');
+
+    class CanvasManager {
+        constructor(options) {
+            this.pendingCanvasMutations = new Map();
+            this.rafStamps = { latestId: 0, invokeId: null };
+            this.frozen = false;
+            this.locked = false;
+            this.processMutation = (target, mutation) => {
+                const newFrame = this.rafStamps.invokeId &&
+                    this.rafStamps.latestId !== this.rafStamps.invokeId;
+                if (newFrame || !this.rafStamps.invokeId)
+                    this.rafStamps.invokeId = this.rafStamps.latestId;
+                if (!this.pendingCanvasMutations.has(target)) {
+                    this.pendingCanvasMutations.set(target, []);
+                }
+                this.pendingCanvasMutations.get(target).push(mutation);
+            };
+            const { sampling = 'all', win, blockClass, blockSelector, recordCanvas, dataURLOptions, } = options;
+            this.mutationCb = options.mutationCb;
+            this.mirror = options.mirror;
+            if (recordCanvas && sampling === 'all')
+                this.initCanvasMutationObserver(win, blockClass, blockSelector);
+            if (recordCanvas && typeof sampling === 'number')
+                this.initCanvasFPSObserver(sampling, win, blockClass, blockSelector, {
+                    dataURLOptions,
+                });
+        }
+        reset() {
+            this.pendingCanvasMutations.clear();
+            this.resetObservers && this.resetObservers();
+        }
+        freeze() {
+            this.frozen = true;
+        }
+        unfreeze() {
+            this.frozen = false;
+        }
+        lock() {
+            this.locked = true;
+        }
+        unlock() {
+            this.locked = false;
+        }
+        initCanvasFPSObserver(fps, win, blockClass, blockSelector, options) {
+            const canvasContextReset = initCanvasContextObserver(win, blockClass, blockSelector);
+            const snapshotInProgressMap = new Map();
+            const worker = new WorkerFactory();
+            worker.onmessage = (e) => {
+                const { id } = e.data;
+                snapshotInProgressMap.set(id, false);
+                if (!('base64' in e.data))
+                    return;
+                const { base64, type, width, height } = e.data;
+                this.mutationCb({
+                    id,
+                    type: CanvasContext['2D'],
+                    commands: [
+                        {
+                            property: 'clearRect',
+                            args: [0, 0, width, height],
+                        },
+                        {
+                            property: 'drawImage',
+                            args: [
+                                {
+                                    rr_type: 'ImageBitmap',
+                                    args: [
+                                        {
+                                            rr_type: 'Blob',
+                                            data: [{ rr_type: 'ArrayBuffer', base64 }],
+                                            type,
+                                        },
+                                    ],
+                                },
+                                0,
+                                0,
+                            ],
+                        },
+                    ],
+                });
+            };
+            const timeBetweenSnapshots = 1000 / fps;
+            let lastSnapshotTime = 0;
+            let rafId;
+            const getCanvas = () => {
+                const matchedCanvas = [];
+                win.document.querySelectorAll('canvas').forEach((canvas) => {
+                    if (!isBlocked(canvas, blockClass, blockSelector, true)) {
+                        matchedCanvas.push(canvas);
+                    }
+                });
+                return matchedCanvas;
+            };
+            const takeCanvasSnapshots = (timestamp) => {
+                if (lastSnapshotTime &&
+                    timestamp - lastSnapshotTime < timeBetweenSnapshots) {
+                    rafId = requestAnimationFrame(takeCanvasSnapshots);
+                    return;
+                }
+                lastSnapshotTime = timestamp;
+                getCanvas()
+                    .forEach((canvas) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    const id = this.mirror.getId(canvas);
+                    if (snapshotInProgressMap.get(id))
+                        return;
+                    snapshotInProgressMap.set(id, true);
+                    if (['webgl', 'webgl2'].includes(canvas.__context)) {
+                        const context = canvas.getContext(canvas.__context);
+                        if (((_a = context === null || context === void 0 ? void 0 : context.getContextAttributes()) === null || _a === void 0 ? void 0 : _a.preserveDrawingBuffer) === false) {
+                            context === null || context === void 0 ? void 0 : context.clear(context.COLOR_BUFFER_BIT);
+                        }
+                    }
+                    const bitmap = yield createImageBitmap(canvas);
+                    worker.postMessage({
+                        id,
+                        bitmap,
+                        width: canvas.width,
+                        height: canvas.height,
+                        dataURLOptions: options.dataURLOptions,
+                    }, [bitmap]);
+                }));
+                rafId = requestAnimationFrame(takeCanvasSnapshots);
+            };
+            rafId = requestAnimationFrame(takeCanvasSnapshots);
+            this.resetObservers = () => {
+                canvasContextReset();
+                cancelAnimationFrame(rafId);
+            };
+        }
+        initCanvasMutationObserver(win, blockClass, blockSelector) {
+            this.startRAFTimestamping();
+            this.startPendingCanvasMutationFlusher();
+            const canvasContextReset = initCanvasContextObserver(win, blockClass, blockSelector);
+            const canvas2DReset = initCanvas2DMutationObserver(this.processMutation.bind(this), win, blockClass, blockSelector);
+            const canvasWebGL1and2Reset = initCanvasWebGLMutationObserver(this.processMutation.bind(this), win, blockClass, blockSelector, this.mirror);
+            this.resetObservers = () => {
+                canvasContextReset();
+                canvas2DReset();
+                canvasWebGL1and2Reset();
+            };
+        }
+        startPendingCanvasMutationFlusher() {
+            requestAnimationFrame(() => this.flushPendingCanvasMutations());
+        }
+        startRAFTimestamping() {
+            const setLatestRAFTimestamp = (timestamp) => {
+                this.rafStamps.latestId = timestamp;
+                requestAnimationFrame(setLatestRAFTimestamp);
+            };
+            requestAnimationFrame(setLatestRAFTimestamp);
+        }
+        flushPendingCanvasMutations() {
+            this.pendingCanvasMutations.forEach((values, canvas) => {
+                const id = this.mirror.getId(canvas);
+                this.flushPendingCanvasMutationFor(canvas, id);
+            });
+            requestAnimationFrame(() => this.flushPendingCanvasMutations());
+        }
+        flushPendingCanvasMutationFor(canvas, id) {
+            if (this.frozen || this.locked) {
+                return;
+            }
+            const valuesWithType = this.pendingCanvasMutations.get(canvas);
+            if (!valuesWithType || id === -1)
+                return;
+            const values = valuesWithType.map((value) => {
+                const rest = __rest(value, ["type"]);
+                return rest;
+            });
+            const { type } = valuesWithType[0];
+            this.mutationCb({ id, type, commands: values });
+            this.pendingCanvasMutations.delete(canvas);
+        }
+    }
+
+    class StylesheetManager {
+        constructor(options) {
+            this.trackedLinkElements = new WeakSet();
+            this.styleMirror = new StyleSheetMirror();
+            this.mutationCb = options.mutationCb;
+            this.adoptedStyleSheetCb = options.adoptedStyleSheetCb;
+        }
+        attachLinkElement(linkEl, childSn) {
+            if ('_cssText' in childSn.attributes)
+                this.mutationCb({
+                    adds: [],
+                    removes: [],
+                    texts: [],
+                    attributes: [
+                        {
+                            id: childSn.id,
+                            attributes: childSn
+                                .attributes,
+                        },
+                    ],
+                });
+            this.trackLinkElement(linkEl);
+        }
+        trackLinkElement(linkEl) {
+            if (this.trackedLinkElements.has(linkEl))
+                return;
+            this.trackedLinkElements.add(linkEl);
+            this.trackStylesheetInLinkElement(linkEl);
+        }
+        adoptStyleSheets(sheets, hostId) {
+            if (sheets.length === 0)
+                return;
+            const adoptedStyleSheetData = {
+                id: hostId,
+                styleIds: [],
+            };
+            const styles = [];
+            for (const sheet of sheets) {
+                let styleId;
+                if (!this.styleMirror.has(sheet)) {
+                    styleId = this.styleMirror.add(sheet);
+                    const rules = Array.from(sheet.rules || CSSRule);
+                    styles.push({
+                        styleId,
+                        rules: rules.map((r, index) => {
+                            return {
+                                rule: getCssRuleString(r),
+                                index,
+                            };
+                        }),
+                    });
+                }
+                else
+                    styleId = this.styleMirror.getId(sheet);
+                adoptedStyleSheetData.styleIds.push(styleId);
+            }
+            if (styles.length > 0)
+                adoptedStyleSheetData.styles = styles;
+            this.adoptedStyleSheetCb(adoptedStyleSheetData);
+        }
+        reset() {
+            this.styleMirror.reset();
+            this.trackedLinkElements = new WeakSet();
+        }
+        trackStylesheetInLinkElement(linkEl) {
+        }
+    }
+
+    function wrapEvent(e) {
+        return Object.assign(Object.assign({}, e), { timestamp: Date.now() });
+    }
+    let wrappedEmit;
+    let takeFullSnapshot;
+    let canvasManager;
+    let recording = false;
+    const mirror = createMirror();
+    function record(options = {}) {
+        const { emit, checkoutEveryNms, checkoutEveryNth, blockClass = 'rr-block', blockSelector = null, ignoreClass = 'rr-ignore', maskTextClass = 'rr-mask', maskTextSelector = null, inlineStylesheet = true, maskAllInputs, maskInputOptions: _maskInputOptions, slimDOMOptions: _slimDOMOptions, maskInputFn, maskTextFn, hooks, packFn, sampling = {}, dataURLOptions = {}, mousemoveWait, recordCanvas = false, recordCrossOriginIframes = false, userTriggeredOnInput = false, collectFonts = false, inlineImages = false, plugins, keepIframeSrcFn = () => false, ignoreCSSAttributes = new Set([]), } = options;
+        const inEmittingFrame = recordCrossOriginIframes
+            ? window.parent === window
+            : true;
+        let passEmitsToParent = false;
+        if (!inEmittingFrame) {
+            try {
+                window.parent.document;
+                passEmitsToParent = false;
+            }
+            catch (e) {
+                passEmitsToParent = true;
+            }
+        }
+        if (inEmittingFrame && !emit) {
+            throw new Error('emit function is required');
+        }
+        if (mousemoveWait !== undefined && sampling.mousemove === undefined) {
+            sampling.mousemove = mousemoveWait;
+        }
+        mirror.reset();
+        const maskInputOptions = maskAllInputs === true
+            ? {
+                color: true,
+                date: true,
+                'datetime-local': true,
+                email: true,
+                month: true,
+                number: true,
+                range: true,
+                search: true,
+                tel: true,
+                text: true,
+                time: true,
+                url: true,
+                week: true,
+                textarea: true,
+                select: true,
+                password: true,
+            }
+            : _maskInputOptions !== undefined
+                ? _maskInputOptions
+                : { password: true };
+        const slimDOMOptions = _slimDOMOptions === true || _slimDOMOptions === 'all'
+            ? {
+                script: true,
+                comment: true,
+                headFavicon: true,
+                headWhitespace: true,
+                headMetaSocial: true,
+                headMetaRobots: true,
+                headMetaHttpEquiv: true,
+                headMetaVerification: true,
+                headMetaAuthorship: _slimDOMOptions === 'all',
+                headMetaDescKeywords: _slimDOMOptions === 'all',
+            }
+            : _slimDOMOptions
+                ? _slimDOMOptions
+                : {};
+        polyfill();
+        let lastFullSnapshotEvent;
+        let incrementalSnapshotCount = 0;
+        const eventProcessor = (e) => {
+            for (const plugin of plugins || []) {
+                if (plugin.eventProcessor) {
+                    e = plugin.eventProcessor(e);
+                }
+            }
+            if (packFn) {
+                e = packFn(e);
+            }
+            return e;
+        };
+        wrappedEmit = (e, isCheckout) => {
+            var _a;
+            if (((_a = mutationBuffers[0]) === null || _a === void 0 ? void 0 : _a.isFrozen()) &&
+                e.type !== EventType.FullSnapshot &&
+                !(e.type === EventType.IncrementalSnapshot &&
+                    e.data.source === IncrementalSource.Mutation)) {
+                mutationBuffers.forEach((buf) => buf.unfreeze());
+            }
+            if (inEmittingFrame) {
+                emit === null || emit === void 0 ? void 0 : emit(eventProcessor(e), isCheckout);
+            }
+            else if (passEmitsToParent) {
+                const message = {
+                    type: 'rrweb',
+                    event: eventProcessor(e),
+                    isCheckout,
+                };
+                window.parent.postMessage(message, '*');
+            }
+            if (e.type === EventType.FullSnapshot) {
+                lastFullSnapshotEvent = e;
+                incrementalSnapshotCount = 0;
+            }
+            else if (e.type === EventType.IncrementalSnapshot) {
+                if (e.data.source === IncrementalSource.Mutation &&
+                    e.data.isAttachIframe) {
+                    return;
+                }
+                incrementalSnapshotCount++;
+                const exceedCount = checkoutEveryNth && incrementalSnapshotCount >= checkoutEveryNth;
+                const exceedTime = checkoutEveryNms &&
+                    e.timestamp - lastFullSnapshotEvent.timestamp > checkoutEveryNms;
+                if (exceedCount || exceedTime) {
+                    takeFullSnapshot(true);
+                }
+            }
+        };
+        const wrappedMutationEmit = (m) => {
+            wrappedEmit(wrapEvent({
+                type: EventType.IncrementalSnapshot,
+                data: Object.assign({ source: IncrementalSource.Mutation }, m),
+            }));
+        };
+        const wrappedScrollEmit = (p) => wrappedEmit(wrapEvent({
+            type: EventType.IncrementalSnapshot,
+            data: Object.assign({ source: IncrementalSource.Scroll }, p),
+        }));
+        const wrappedCanvasMutationEmit = (p) => wrappedEmit(wrapEvent({
+            type: EventType.IncrementalSnapshot,
+            data: Object.assign({ source: IncrementalSource.CanvasMutation }, p),
+        }));
+        const wrappedAdoptedStyleSheetEmit = (a) => wrappedEmit(wrapEvent({
+            type: EventType.IncrementalSnapshot,
+            data: Object.assign({ source: IncrementalSource.AdoptedStyleSheet }, a),
+        }));
+        const stylesheetManager = new StylesheetManager({
+            mutationCb: wrappedMutationEmit,
+            adoptedStyleSheetCb: wrappedAdoptedStyleSheetEmit,
+        });
+        const iframeManager = new IframeManager({
+            mirror,
+            mutationCb: wrappedMutationEmit,
+            stylesheetManager: stylesheetManager,
+            recordCrossOriginIframes,
+            wrappedEmit,
+        });
+        for (const plugin of plugins || []) {
+            if (plugin.getMirror)
+                plugin.getMirror({
+                    nodeMirror: mirror,
+                    crossOriginIframeMirror: iframeManager.crossOriginIframeMirror,
+                    crossOriginIframeStyleMirror: iframeManager.crossOriginIframeStyleMirror,
+                });
+        }
+        canvasManager = new CanvasManager({
+            recordCanvas,
+            mutationCb: wrappedCanvasMutationEmit,
+            win: window,
+            blockClass,
+            blockSelector,
+            mirror,
+            sampling: sampling.canvas,
+            dataURLOptions,
+        });
+        const shadowDomManager = new ShadowDomManager({
+            mutationCb: wrappedMutationEmit,
+            scrollCb: wrappedScrollEmit,
+            bypassOptions: {
+                blockClass,
+                blockSelector,
+                maskTextClass,
+                maskTextSelector,
+                inlineStylesheet,
+                maskInputOptions,
+                dataURLOptions,
+                maskTextFn,
+                maskInputFn,
+                recordCanvas,
+                inlineImages,
+                sampling,
+                slimDOMOptions,
+                iframeManager,
+                stylesheetManager,
+                canvasManager,
+                keepIframeSrcFn,
+            },
+            mirror,
+        });
+        takeFullSnapshot = (isCheckout = false) => {
+            var _a, _b, _c, _d, _e, _f;
+            wrappedEmit(wrapEvent({
+                type: EventType.Meta,
+                data: {
+                    href: window.location.href,
+                    width: getWindowWidth(),
+                    height: getWindowHeight(),
+                },
+            }), isCheckout);
+            stylesheetManager.reset();
+            mutationBuffers.forEach((buf) => buf.lock());
+            const node = snapshot(document, {
+                mirror,
+                blockClass,
+                blockSelector,
+                maskTextClass,
+                maskTextSelector,
+                inlineStylesheet,
+                maskAllInputs: maskInputOptions,
+                maskTextFn,
+                slimDOM: slimDOMOptions,
+                dataURLOptions,
+                recordCanvas,
+                inlineImages,
+                onSerialize: (n) => {
+                    if (isSerializedIframe(n, mirror)) {
+                        iframeManager.addIframe(n);
+                    }
+                    if (isSerializedStylesheet(n, mirror)) {
+                        stylesheetManager.trackLinkElement(n);
+                    }
+                    if (hasShadowRoot(n)) {
+                        shadowDomManager.addShadowRoot(n.shadowRoot, document);
+                    }
+                },
+                onIframeLoad: (iframe, childSn) => {
+                    iframeManager.attachIframe(iframe, childSn);
+                    shadowDomManager.observeAttachShadow(iframe);
+                },
+                onStylesheetLoad: (linkEl, childSn) => {
+                    stylesheetManager.attachLinkElement(linkEl, childSn);
+                },
+                keepIframeSrcFn,
+            });
+            if (!node) {
+                return console.warn('Failed to snapshot the document');
+            }
+            wrappedEmit(wrapEvent({
+                type: EventType.FullSnapshot,
+                data: {
+                    node,
+                    initialOffset: {
+                        left: window.pageXOffset !== undefined
+                            ? window.pageXOffset
+                            : (document === null || document === void 0 ? void 0 : document.documentElement.scrollLeft) ||
+                                ((_b = (_a = document === null || document === void 0 ? void 0 : document.body) === null || _a === void 0 ? void 0 : _a.parentElement) === null || _b === void 0 ? void 0 : _b.scrollLeft) ||
+                                ((_c = document === null || document === void 0 ? void 0 : document.body) === null || _c === void 0 ? void 0 : _c.scrollLeft) ||
+                                0,
+                        top: window.pageYOffset !== undefined
+                            ? window.pageYOffset
+                            : (document === null || document === void 0 ? void 0 : document.documentElement.scrollTop) ||
+                                ((_e = (_d = document === null || document === void 0 ? void 0 : document.body) === null || _d === void 0 ? void 0 : _d.parentElement) === null || _e === void 0 ? void 0 : _e.scrollTop) ||
+                                ((_f = document === null || document === void 0 ? void 0 : document.body) === null || _f === void 0 ? void 0 : _f.scrollTop) ||
+                                0,
+                    },
+                },
+            }));
+            mutationBuffers.forEach((buf) => buf.unlock());
+            if (document.adoptedStyleSheets && document.adoptedStyleSheets.length > 0)
+                stylesheetManager.adoptStyleSheets(document.adoptedStyleSheets, mirror.getId(document));
+        };
+        try {
+            const handlers = [];
+            handlers.push(on('DOMContentLoaded', () => {
+                wrappedEmit(wrapEvent({
+                    type: EventType.DomContentLoaded,
+                    data: {},
+                }));
+            }));
+            const observe = (doc) => {
+                var _a;
+                return initObservers({
+                    mutationCb: wrappedMutationEmit,
+                    mousemoveCb: (positions, source) => wrappedEmit(wrapEvent({
+                        type: EventType.IncrementalSnapshot,
+                        data: {
+                            source,
+                            positions,
+                        },
+                    })),
+                    mouseInteractionCb: (d) => wrappedEmit(wrapEvent({
+                        type: EventType.IncrementalSnapshot,
+                        data: Object.assign({ source: IncrementalSource.MouseInteraction }, d),
+                    })),
+                    scrollCb: wrappedScrollEmit,
+                    viewportResizeCb: (d) => wrappedEmit(wrapEvent({
+                        type: EventType.IncrementalSnapshot,
+                        data: Object.assign({ source: IncrementalSource.ViewportResize }, d),
+                    })),
+                    inputCb: (v) => wrappedEmit(wrapEvent({
+                        type: EventType.IncrementalSnapshot,
+                        data: Object.assign({ source: IncrementalSource.Input }, v),
+                    })),
+                    mediaInteractionCb: (p) => wrappedEmit(wrapEvent({
+                        type: EventType.IncrementalSnapshot,
+                        data: Object.assign({ source: IncrementalSource.MediaInteraction }, p),
+                    })),
+                    styleSheetRuleCb: (r) => wrappedEmit(wrapEvent({
+                        type: EventType.IncrementalSnapshot,
+                        data: Object.assign({ source: IncrementalSource.StyleSheetRule }, r),
+                    })),
+                    styleDeclarationCb: (r) => wrappedEmit(wrapEvent({
+                        type: EventType.IncrementalSnapshot,
+                        data: Object.assign({ source: IncrementalSource.StyleDeclaration }, r),
+                    })),
+                    canvasMutationCb: wrappedCanvasMutationEmit,
+                    fontCb: (p) => wrappedEmit(wrapEvent({
+                        type: EventType.IncrementalSnapshot,
+                        data: Object.assign({ source: IncrementalSource.Font }, p),
+                    })),
+                    selectionCb: (p) => {
+                        wrappedEmit(wrapEvent({
+                            type: EventType.IncrementalSnapshot,
+                            data: Object.assign({ source: IncrementalSource.Selection }, p),
+                        }));
+                    },
+                    blockClass,
+                    ignoreClass,
+                    maskTextClass,
+                    maskTextSelector,
+                    maskInputOptions,
+                    inlineStylesheet,
+                    sampling,
+                    recordCanvas,
+                    inlineImages,
+                    userTriggeredOnInput,
+                    collectFonts,
+                    doc,
+                    maskInputFn,
+                    maskTextFn,
+                    keepIframeSrcFn,
+                    blockSelector,
+                    slimDOMOptions,
+                    dataURLOptions,
+                    mirror,
+                    iframeManager,
+                    stylesheetManager,
+                    shadowDomManager,
+                    canvasManager,
+                    ignoreCSSAttributes,
+                    plugins: ((_a = plugins === null || plugins === void 0 ? void 0 : plugins.filter((p) => p.observer)) === null || _a === void 0 ? void 0 : _a.map((p) => ({
+                        observer: p.observer,
+                        options: p.options,
+                        callback: (payload) => wrappedEmit(wrapEvent({
+                            type: EventType.Plugin,
+                            data: {
+                                plugin: p.name,
+                                payload,
+                            },
+                        })),
+                    }))) || [],
+                }, hooks);
+            };
+            iframeManager.addLoadListener((iframeEl) => {
+                handlers.push(observe(iframeEl.contentDocument));
+            });
+            const init = () => {
+                takeFullSnapshot();
+                handlers.push(observe(document));
+                recording = true;
+            };
+            if (document.readyState === 'interactive' ||
+                document.readyState === 'complete') {
+                init();
+            }
+            else {
+                handlers.push(on('load', () => {
+                    wrappedEmit(wrapEvent({
+                        type: EventType.Load,
+                        data: {},
+                    }));
+                    init();
+                }, window));
+            }
+            return () => {
+                handlers.forEach((h) => h());
+                recording = false;
+            };
+        }
+        catch (error) {
+            console.warn(error);
+        }
+    }
+    record.addCustomEvent = (tag, payload) => {
+        if (!recording) {
+            throw new Error('please add custom event after start recording');
+        }
+        wrappedEmit(wrapEvent({
+            type: EventType.Custom,
+            data: {
+                tag,
+                payload,
+            },
+        }));
+    };
+    record.freezePage = () => {
+        mutationBuffers.forEach((buf) => buf.freeze());
+    };
+    record.takeFullSnapshot = (isCheckout) => {
+        if (!recording) {
+            throw new Error('please take full snapshot after start recording');
+        }
+        takeFullSnapshot(isCheckout);
+    };
+    record.mirror = mirror;
+
+    var u8 = Uint8Array, u16 = Uint16Array, u32 = Uint32Array;
+    var fleb = new u8([
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      1,
+      1,
+      2,
+      2,
+      2,
+      2,
+      3,
+      3,
+      3,
+      3,
+      4,
+      4,
+      4,
+      4,
+      5,
+      5,
+      5,
+      5,
+      0,
+      /* unused */
+      0,
+      0,
+      /* impossible */
+      0
+    ]);
+    var fdeb = new u8([
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      2,
+      2,
+      3,
+      3,
+      4,
+      4,
+      5,
+      5,
+      6,
+      6,
+      7,
+      7,
+      8,
+      8,
+      9,
+      9,
+      10,
+      10,
+      11,
+      11,
+      12,
+      12,
+      13,
+      13,
+      /* unused */
+      0,
+      0
+    ]);
+    var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+    var freb = function(eb, start) {
+      var b = new u16(31);
+      for (var i = 0; i < 31; ++i) {
+        b[i] = start += 1 << eb[i - 1];
+      }
+      var r = new u32(b[30]);
+      for (var i = 1; i < 30; ++i) {
+        for (var j = b[i]; j < b[i + 1]; ++j) {
+          r[j] = j - b[i] << 5 | i;
+        }
+      }
+      return [b, r];
+    };
+    var _a = freb(fleb, 2), fl = _a[0], revfl = _a[1];
+    fl[28] = 258, revfl[258] = 28;
+    var _b = freb(fdeb, 0), revfd = _b[1];
+    var rev = new u16(32768);
+    for (var i = 0; i < 32768; ++i) {
+      var x = (i & 43690) >>> 1 | (i & 21845) << 1;
+      x = (x & 52428) >>> 2 | (x & 13107) << 2;
+      x = (x & 61680) >>> 4 | (x & 3855) << 4;
+      rev[i] = ((x & 65280) >>> 8 | (x & 255) << 8) >>> 1;
+    }
+    var hMap = function(cd, mb, r) {
+      var s = cd.length;
+      var i = 0;
+      var l = new u16(mb);
+      for (; i < s; ++i)
+        ++l[cd[i] - 1];
+      var le = new u16(mb);
+      for (i = 0; i < mb; ++i) {
+        le[i] = le[i - 1] + l[i - 1] << 1;
+      }
+      var co;
+      if (r) {
+        co = new u16(1 << mb);
+        var rvb = 15 - mb;
+        for (i = 0; i < s; ++i) {
+          if (cd[i]) {
+            var sv = i << 4 | cd[i];
+            var r_1 = mb - cd[i];
+            var v = le[cd[i] - 1]++ << r_1;
+            for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
+              co[rev[v] >>> rvb] = sv;
+            }
+          }
+        }
+      } else {
+        co = new u16(s);
+        for (i = 0; i < s; ++i)
+          co[i] = rev[le[cd[i] - 1]++] >>> 15 - cd[i];
+      }
+      return co;
+    };
+    var flt = new u8(288);
+    for (var i = 0; i < 144; ++i)
+      flt[i] = 8;
+    for (var i = 144; i < 256; ++i)
+      flt[i] = 9;
+    for (var i = 256; i < 280; ++i)
+      flt[i] = 7;
+    for (var i = 280; i < 288; ++i)
+      flt[i] = 8;
+    var fdt = new u8(32);
+    for (var i = 0; i < 32; ++i)
+      fdt[i] = 5;
+    var flm = /* @__PURE__ */ hMap(flt, 9, 0);
+    var fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
+    var shft = function(p) {
+      return (p / 8 >> 0) + (p & 7 && 1);
+    };
+    var slc = function(v, s, e) {
+      if (e == null || e > v.length)
+        e = v.length;
+      var n = new (v instanceof u16 ? u16 : v instanceof u32 ? u32 : u8)(e - s);
+      n.set(v.subarray(s, e));
+      return n;
+    };
+    var wbits = function(d, p, v) {
+      v <<= p & 7;
+      var o = p / 8 >> 0;
+      d[o] |= v;
+      d[o + 1] |= v >>> 8;
+    };
+    var wbits16 = function(d, p, v) {
+      v <<= p & 7;
+      var o = p / 8 >> 0;
+      d[o] |= v;
+      d[o + 1] |= v >>> 8;
+      d[o + 2] |= v >>> 16;
+    };
+    var hTree = function(d, mb) {
+      var t = [];
+      for (var i = 0; i < d.length; ++i) {
+        if (d[i])
+          t.push({ s: i, f: d[i] });
+      }
+      var s = t.length;
+      var t2 = t.slice();
+      if (!s)
+        return [new u8(0), 0];
+      if (s == 1) {
+        var v = new u8(t[0].s + 1);
+        v[t[0].s] = 1;
+        return [v, 1];
+      }
+      t.sort(function(a, b) {
+        return a.f - b.f;
+      });
+      t.push({ s: -1, f: 25001 });
+      var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2;
+      t[0] = { s: -1, f: l.f + r.f, l, r };
+      while (i1 != s - 1) {
+        l = t[t[i0].f < t[i2].f ? i0++ : i2++];
+        r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++];
+        t[i1++] = { s: -1, f: l.f + r.f, l, r };
+      }
+      var maxSym = t2[0].s;
+      for (var i = 1; i < s; ++i) {
+        if (t2[i].s > maxSym)
+          maxSym = t2[i].s;
+      }
+      var tr = new u16(maxSym + 1);
+      var mbt = ln(t[i1 - 1], tr, 0);
+      if (mbt > mb) {
+        var i = 0, dt = 0;
+        var lft = mbt - mb, cst = 1 << lft;
+        t2.sort(function(a, b) {
+          return tr[b.s] - tr[a.s] || a.f - b.f;
+        });
+        for (; i < s; ++i) {
+          var i2_1 = t2[i].s;
+          if (tr[i2_1] > mb) {
+            dt += cst - (1 << mbt - tr[i2_1]);
+            tr[i2_1] = mb;
+          } else
+            break;
+        }
+        dt >>>= lft;
+        while (dt > 0) {
+          var i2_2 = t2[i].s;
+          if (tr[i2_2] < mb)
+            dt -= 1 << mb - tr[i2_2]++ - 1;
+          else
+            ++i;
+        }
+        for (; i >= 0 && dt; --i) {
+          var i2_3 = t2[i].s;
+          if (tr[i2_3] == mb) {
+            --tr[i2_3];
+            ++dt;
+          }
+        }
+        mbt = mb;
+      }
+      return [new u8(tr), mbt];
+    };
+    var ln = function(n, l, d) {
+      return n.s == -1 ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) : l[n.s] = d;
+    };
+    var lc = function(c) {
+      var s = c.length;
+      while (s && !c[--s])
+        ;
+      var cl = new u16(++s);
+      var cli = 0, cln = c[0], cls = 1;
+      var w = function(v) {
+        cl[cli++] = v;
+      };
+      for (var i = 1; i <= s; ++i) {
+        if (c[i] == cln && i != s)
+          ++cls;
+        else {
+          if (!cln && cls > 2) {
+            for (; cls > 138; cls -= 138)
+              w(32754);
+            if (cls > 2) {
+              w(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
+              cls = 0;
+            }
+          } else if (cls > 3) {
+            w(cln), --cls;
+            for (; cls > 6; cls -= 6)
+              w(8304);
+            if (cls > 2)
+              w(cls - 3 << 5 | 8208), cls = 0;
+          }
+          while (cls--)
+            w(cln);
+          cls = 1;
+          cln = c[i];
+        }
+      }
+      return [cl.subarray(0, cli), s];
+    };
+    var clen = function(cf, cl) {
+      var l = 0;
+      for (var i = 0; i < cl.length; ++i)
+        l += cf[i] * cl[i];
+      return l;
+    };
+    var wfblk = function(out, pos, dat) {
+      var s = dat.length;
+      var o = shft(pos + 2);
+      out[o] = s & 255;
+      out[o + 1] = s >>> 8;
+      out[o + 2] = out[o] ^ 255;
+      out[o + 3] = out[o + 1] ^ 255;
+      for (var i = 0; i < s; ++i)
+        out[o + i + 4] = dat[i];
+      return (o + 4 + s) * 8;
+    };
+    var wblk = function(dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
+      wbits(out, p++, final);
+      ++lf[256];
+      var _a2 = hTree(lf, 15), dlt = _a2[0], mlb = _a2[1];
+      var _b2 = hTree(df, 15), ddt = _b2[0], mdb = _b2[1];
+      var _c = lc(dlt), lclt = _c[0], nlc = _c[1];
+      var _d = lc(ddt), lcdt = _d[0], ndc = _d[1];
+      var lcfreq = new u16(19);
+      for (var i = 0; i < lclt.length; ++i)
+        lcfreq[lclt[i] & 31]++;
+      for (var i = 0; i < lcdt.length; ++i)
+        lcfreq[lcdt[i] & 31]++;
+      var _e = hTree(lcfreq, 7), lct = _e[0], mlcb = _e[1];
+      var nlcc = 19;
+      for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
+        ;
+      var flen = bl + 5 << 3;
+      var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
+      var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + (2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18]);
+      if (flen <= ftlen && flen <= dtlen)
+        return wfblk(out, p, dat.subarray(bs, bs + bl));
+      var lm, ll, dm, dl;
+      wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
+      if (dtlen < ftlen) {
+        lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
+        var llm = hMap(lct, mlcb, 0);
+        wbits(out, p, nlc - 257);
+        wbits(out, p + 5, ndc - 1);
+        wbits(out, p + 10, nlcc - 4);
+        p += 14;
+        for (var i = 0; i < nlcc; ++i)
+          wbits(out, p + 3 * i, lct[clim[i]]);
+        p += 3 * nlcc;
+        var lcts = [lclt, lcdt];
+        for (var it = 0; it < 2; ++it) {
+          var clct = lcts[it];
+          for (var i = 0; i < clct.length; ++i) {
+            var len = clct[i] & 31;
+            wbits(out, p, llm[len]), p += lct[len];
+            if (len > 15)
+              wbits(out, p, clct[i] >>> 5 & 127), p += clct[i] >>> 12;
+          }
+        }
+      } else {
+        lm = flm, ll = flt, dm = fdm, dl = fdt;
+      }
+      for (var i = 0; i < li; ++i) {
+        if (syms[i] > 255) {
+          var len = syms[i] >>> 18 & 31;
+          wbits16(out, p, lm[len + 257]), p += ll[len + 257];
+          if (len > 7)
+            wbits(out, p, syms[i] >>> 23 & 31), p += fleb[len];
+          var dst = syms[i] & 31;
+          wbits16(out, p, dm[dst]), p += dl[dst];
+          if (dst > 3)
+            wbits16(out, p, syms[i] >>> 5 & 8191), p += fdeb[dst];
+        } else {
+          wbits16(out, p, lm[syms[i]]), p += ll[syms[i]];
+        }
+      }
+      wbits16(out, p, lm[256]);
+      return p + ll[256];
+    };
+    var deo = /* @__PURE__ */ new u32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
+    var dflt = function(dat, lvl, plvl, pre, post, lst) {
+      var s = dat.length;
+      var o = new u8(pre + s + 5 * (1 + Math.floor(s / 7e3)) + post);
+      var w = o.subarray(pre, o.length - post);
+      var pos = 0;
+      if (!lvl || s < 8) {
+        for (var i = 0; i <= s; i += 65535) {
+          var e = i + 65535;
+          if (e < s) {
+            pos = wfblk(w, pos, dat.subarray(i, e));
+          } else {
+            w[i] = lst;
+            pos = wfblk(w, pos, dat.subarray(i, s));
+          }
+        }
+      } else {
+        var opt = deo[lvl - 1];
+        var n = opt >>> 13, c = opt & 8191;
+        var msk_1 = (1 << plvl) - 1;
+        var prev = new u16(32768), head = new u16(msk_1 + 1);
+        var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
+        var hsh = function(i2) {
+          return (dat[i2] ^ dat[i2 + 1] << bs1_1 ^ dat[i2 + 2] << bs2_1) & msk_1;
+        };
+        var syms = new u32(25e3);
+        var lf = new u16(288), df = new u16(32);
+        var lc_1 = 0, eb = 0, i = 0, li = 0, wi = 0, bs = 0;
+        for (; i < s; ++i) {
+          var hv = hsh(i);
+          var imod = i & 32767;
+          var pimod = head[hv];
+          prev[imod] = pimod;
+          head[hv] = imod;
+          if (wi <= i) {
+            var rem = s - i;
+            if ((lc_1 > 7e3 || li > 24576) && rem > 423) {
+              pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);
+              li = lc_1 = eb = 0, bs = i;
+              for (var j = 0; j < 286; ++j)
+                lf[j] = 0;
+              for (var j = 0; j < 30; ++j)
+                df[j] = 0;
+            }
+            var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
+            if (rem > 2 && hv == hsh(i - dif)) {
+              var maxn = Math.min(n, rem) - 1;
+              var maxd = Math.min(32767, i);
+              var ml = Math.min(258, rem);
+              while (dif <= maxd && --ch_1 && imod != pimod) {
+                if (dat[i + l] == dat[i + l - dif]) {
+                  var nl = 0;
+                  for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl)
+                    ;
+                  if (nl > l) {
+                    l = nl, d = dif;
+                    if (nl > maxn)
+                      break;
+                    var mmd = Math.min(dif, nl - 2);
+                    var md = 0;
+                    for (var j = 0; j < mmd; ++j) {
+                      var ti = i - dif + j + 32768 & 32767;
+                      var pti = prev[ti];
+                      var cd = ti - pti + 32768 & 32767;
+                      if (cd > md)
+                        md = cd, pimod = ti;
+                    }
+                  }
+                }
+                imod = pimod, pimod = prev[imod];
+                dif += imod - pimod + 32768 & 32767;
+              }
+            }
+            if (d) {
+              syms[li++] = 268435456 | revfl[l] << 18 | revfd[d];
+              var lin = revfl[l] & 31, din = revfd[d] & 31;
+              eb += fleb[lin] + fdeb[din];
+              ++lf[257 + lin];
+              ++df[din];
+              wi = i + l;
+              ++lc_1;
+            } else {
+              syms[li++] = dat[i];
+              ++lf[dat[i]];
+            }
+          }
+        }
+        pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);
+      }
+      return slc(o, 0, pre + shft(pos) + post);
+    };
+    var adler = function() {
+      var a = 1, b = 0;
+      return {
+        p: function(d) {
+          var n = a, m = b;
+          var l = d.length;
+          for (var i = 0; i != l; ) {
+            var e = Math.min(i + 5552, l);
+            for (; i < e; ++i)
+              n += d[i], m += n;
+            n %= 65521, m %= 65521;
+          }
+          a = n, b = m;
+        },
+        d: function() {
+          return (a >>> 8 << 16 | (b & 255) << 8 | b >>> 8) + ((a & 255) << 23) * 2;
+        }
+      };
+    };
+    var dopt = function(dat, opt, pre, post, st) {
+      return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 12 + opt.mem, pre, post, true);
+    };
+    var wbytes = function(d, b, v) {
+      for (; v; ++b)
+        d[b] = v, v >>>= 8;
+    };
+    var zlh = function(c, o) {
+      var lv = o.level, fl2 = lv == 0 ? 0 : lv < 6 ? 1 : lv == 9 ? 3 : 2;
+      c[0] = 120, c[1] = fl2 << 6 | (fl2 ? 32 - 2 * fl2 : 1);
+    };
+    function zlibSync(data, opts) {
+      if (opts === void 0) {
+        opts = {};
+      }
+      var a = adler();
+      a.p(data);
+      var d = dopt(data, opts, 2, 4);
+      return zlh(d, opts), wbytes(d, d.length - 4, a.d()), d;
+    }
+    function strToU8(str, latin1) {
+      var l = str.length;
+      if (typeof TextEncoder != "undefined")
+        return new TextEncoder().encode(str);
+      var ar = new u8(str.length + (str.length >>> 1));
+      var ai = 0;
+      var w = function(v) {
+        ar[ai++] = v;
+      };
+      for (var i = 0; i < l; ++i) {
+        if (ai + 5 > ar.length) {
+          var n = new u8(ai + 8 + (l - i << 1));
+          n.set(ar);
+          ar = n;
+        }
+        var c = str.charCodeAt(i);
+        if (c < 128 || latin1)
+          w(c);
+        else if (c < 2048)
+          w(192 | c >>> 6), w(128 | c & 63);
+        else if (c > 55295 && c < 57344)
+          c = 65536 + (c & 1023 << 10) | str.charCodeAt(++i) & 1023, w(240 | c >>> 18), w(128 | c >>> 12 & 63), w(128 | c >>> 6 & 63), w(128 | c & 63);
+        else
+          w(224 | c >>> 12), w(128 | c >>> 6 & 63), w(128 | c & 63);
+      }
+      return slc(ar, 0, ai);
+    }
+    function strFromU8(dat, latin1) {
+      var r = "";
+      for (var i = 0; i < dat.length; ) {
+        var c = dat[i++];
+        r += String.fromCharCode(c);
+      }
+      return r;
+    }
+    const MARK = "v1";
+
+    const pack = (event) => {
+      const _e = {
+        ...event,
+        v: MARK
+      };
+      return strFromU8(zlibSync(strToU8(JSON.stringify(_e))));
+    };
+
+    class D2DWebSessionTracker {
+        constructor(config) {
+            this.name = 'session-tracker';
+            this.version = '"0.9.0"';
+            this.context = null;
+            this.config = {};
+            this.userConfig = null;
+            this.sessionStartTime = 0;
+            this.isActive = false;
+            this.stopRecording = null;
+            this.sessionEvents = [];
+            this.sessionId = '';
+            this.currentSessionSize = 0;
+            this.lastBatchTime = 0;
+            this.activeBatchCount = 0;
+            // Event ordering and batch management
+            this.pendingEvents = []; // Events waiting to be sent
+            this.sentEventCount = 0; // Total events sent successfully
+            // Delayed URL management for final batch
+            this.delayedS3Url = null;
+            this.delayedUrlTtl = 0;
+            this.delayedUrlRefreshTimer = null;
+            this.userConfig = config || {};
+        }
+        // MARK: Init
+        init(context, config) {
+            console.log('D2DWebSessionTracker init', config);
+            this.context = context;
+            const webSessionsConfig = typeof config?.webSessions === 'object'
+                ? config?.webSessions
+                : null;
+            const defaultConfig = {
+                enableSessionRecording: config?.webSessions === true || webSessionsConfig?.enabled || true,
+                maxBatchSize: 1024 * 1024, // 1MB default
+                maxSessionDuration: null,
+                batchSize: 50, // 50 events per batch
+                batchInterval: 30000, // 30 seconds between batches
+                compressionEnabled: false,
+                recordingOptions: {
+                    recordCanvas: true,
+                    recordCrossOriginIframes: false,
+                    recordAfter: 'DOMContentLoaded',
+                    maskAllInputs: false,
+                    maskInputOptions: {
+                        password: true,
+                        email: true,
+                        text: false,
+                    },
+                    blockClass: 'sensitive-field',
+                    slimDOMOptions: {
+                        script: false,
+                        comment: true,
+                        headFavicon: true,
+                        headWhitespace: true,
+                        headMetaDescKeywords: true,
+                        headMetaSocial: true,
+                        headMetaRobots: true,
+                        headMetaHttpEquiv: true,
+                        headMetaAuthorship: true,
+                        headMetaVerification: true,
+                    },
+                    sampling: {
+                        scroll: 150,
+                        mouseInteraction: true,
+                        input: 'last',
+                        mutation: true,
+                    },
+                    ...(this.userConfig ? this.userConfig : {}),
+                    ...(this.config.recordingOptions ? this.config.recordingOptions : {}),
+                },
+            };
+            this.config = { ...defaultConfig };
+            console.log('D2DWebSessionTracker initialized', this.config);
+        }
+        // MARK: Start
+        start() {
+            console.log('D2DWebSessionTracker start');
+            if (!this.context || this.isActive) {
+                this.context?.logger.error('Session tracker is not initialized or already active');
+                return;
+            }
+            // Clear any existing delayed URL refresh timer
+            if (this.delayedUrlRefreshTimer) {
+                clearTimeout(this.delayedUrlRefreshTimer);
+                this.delayedUrlRefreshTimer = null;
+            }
+            this.isActive = true;
+            this.sessionStartTime = Date.now();
+            this.sessionId = String(this.context.userManager.getSessionId());
+            this.sessionEvents = [];
+            this.pendingEvents = [];
+            this.currentSessionSize = 0;
+            this.lastBatchTime = Date.now();
+            this.sentEventCount = 0;
+            this.delayedS3Url = null;
+            this.delayedUrlTtl = 0;
+            // Check recording logic
+            if (this.config.enableSessionRecording) {
+                this.handleRecordingStart();
+            }
+        }
+        // MARK: Handle Recording Start
+        async handleRecordingStart() {
+            if (!this.context)
+                return;
+            const isRecordingActive = this.context.getPluginField('isRecordingActive');
+            const isNewSession = this.context.isNewSession;
+            console.log('isRecordingActive', isRecordingActive);
+            console.log('isNewSession', isNewSession);
+            if (!isNewSession && isRecordingActive) {
+                this.startSessionRecording();
+                return;
+            }
+            if (isNewSession || !isRecordingActive) {
+                try {
+                    const appId = this.context.appManager.getAppId();
+                    // GET /sessions/configurations/get?appId={appId}
+                    const url = this.context.api.buildUrl(['sessions', 'configurations', 'get'], { appId });
+                    const response = await this.sendRequest(url, null, 'GET');
+                    if (response && response.data) {
+                        const config = response.data;
+                        if (config.blocked || !config.active) {
+                            this.context.logger.debug(`Session configuration is ${config.blocked ? 'blocked' : 'inactive'}`);
+                            this.context.setPluginField('isRecordingActive', false);
+                            this.isActive = false;
+                            return;
+                        }
+                        const shouldRecord = Math.random() * 100 < config.record_chance_percent;
+                        if (shouldRecord) {
+                            this.context.setPluginField('isRecordingActive', true);
+                            this.startSessionRecording();
+                        }
+                        else {
+                            this.context.setPluginField('isRecordingActive', false);
+                        }
+                    }
+                }
+                catch (error) {
+                    this.context.logger.error('Failed to fetch session configuration', {
+                        error,
+                    });
+                    this.context.setPluginField('isRecordingActive', false);
+                    this.isActive = false;
+                }
+            }
+        }
+        // MARK: Stop
+        stop() {
+            if (!this.isActive)
+                return;
+            this.context?.setPluginField('isRecordingActive', false);
+            this.isActive = false;
+            // Clear delayed URL refresh timer
+            if (this.delayedUrlRefreshTimer) {
+                clearTimeout(this.delayedUrlRefreshTimer);
+                this.delayedUrlRefreshTimer = null;
+            }
+            // Stop session recording
+            if (this.config.enableSessionRecording && this.stopRecording) {
+                this.stopRecording();
+                this.stopRecording = null;
+                // Handle async operation without blocking - onBlur / stop will handle final batch
+            }
+        }
+        // MARK: Destroy
+        destroy() {
+            this.stop();
+            // Ensure timer is cleared
+            if (this.delayedUrlRefreshTimer) {
+                clearTimeout(this.delayedUrlRefreshTimer);
+                this.delayedUrlRefreshTimer = null;
+            }
+            this.context = null;
+        }
+        // MARK: On Event
+        onEvent(eventCode, _bundle) {
+            if (!this.isActive)
+                return;
+            if (eventCode === 'session_start') {
+                this.sessionStartTime = Date.now();
+            }
+        }
+        // MARK: On User Change
+        onUserChange(_userId) {
+            if (!this.isActive)
+                return;
+            this.sessionStartTime = Date.now();
+        }
+        // MARK: On Focus
+        onFocus() {
+            if (!this.isActive)
+                return;
+            this.start();
+        }
+        // MARK: On Blur
+        onBlur() {
+            if (!this.isActive)
+                return;
+            console.log('onBlur');
+            this.stop();
+            // Send final batch via addWithFile
+            this.sendFinalBatch().catch(err => {
+                this.context?.logger.error('Error sending final batch', { error: err });
+            });
+        }
+        // MARK: On Before Unload
+        onBeforeUnload() {
+            if (!this.isActive)
+                return;
+            console.log('onBeforeUnload');
+            this.stop();
+            // Send final batch via addWithFile
+            this.sendFinalBatch().catch(err => {
+                this.context?.logger.error('Error sending final batch', { error: err });
+            });
+        }
+        // MARK: On Tracking Change
+        onTrackingChange(isTracking) {
+            if (!this.isActive)
+                return;
+            if (isTracking) {
+                this.start();
+            }
+            else {
+                this.destroy();
+            }
+        }
+        // MARK: On Session Start
+        onSessionStart() {
+            if (!this.isActive)
+                return;
+            this.start();
+        }
+        // MARK: On Session End
+        onSessionEnd() {
+            if (!this.isActive)
+                return;
+            this.stop();
+        }
+        // MARK: Start Session Recording
+        startSessionRecording() {
+            if (!this.config.enableSessionRecording)
+                return;
+            // Fetch delayed URL when recording starts
+            this.fetchDelayedUrl();
+            const recordOptions = {
+                emit: (event) => {
+                    // Add event to both active and pending collections
+                    this.sessionEvents.push(event);
+                    this.pendingEvents.push(event);
+                    this.currentSessionSize += JSON.stringify(event).length;
+                    // Check if we need to send batch due to size, duration, or batch size limits
+                    this.checkBatchLimits();
+                },
+                ...this.config.recordingOptions,
+            };
+            // Add packFn for compression if enabled
+            if (this.config.compressionEnabled) {
+                recordOptions.packFn = pack;
+            }
+            const stopFn = record(recordOptions);
+            this.stopRecording = stopFn || null;
+        }
+        // MARK: Check Batch Limits
+        checkBatchLimits() {
+            const sessionDuration = Date.now() - this.sessionStartTime;
+            const batchSizeReached = this.pendingEvents.length >= (this.config.batchSize || 50);
+            const sizeLimitReached = this.currentSessionSize >= (this.config.maxBatchSize || 1024 * 1024);
+            const durationLimitReached = this.config.maxSessionDuration &&
+                sessionDuration >= this.config.maxSessionDuration;
+            const timeLimitReached = Date.now() - this.lastBatchTime >= (this.config.batchInterval || 30000);
+            if (batchSizeReached ||
+                sizeLimitReached ||
+                durationLimitReached ||
+                timeLimitReached) {
+                // Handle async operation without blocking
+                this.sendBatchToBackend().catch(error => {
+                    this.context?.logger.error('Error in checkBatchLimits sendBatchToBackend', {
+                        error: error instanceof Error ? error.message : error,
+                        pendingEventsCount: this.pendingEvents.length,
+                    });
+                });
+            }
+        }
+        // MARK: Send Batch To Backend
+        async sendBatchToBackend() {
+            if (!this.pendingEvents.length || !this.context)
+                return;
+            // Take a snapshot of events to send and immediately remove them from pending
+            // This allows concurrent batch sends without duplicate events
+            const eventsToSend = [...this.pendingEvents];
+            this.pendingEvents = []; // Clear immediately to prevent duplicates in concurrent sends
+            // Update session size immediately
+            const sentSize = eventsToSend.reduce((total, event) => total + JSON.stringify(event).length, 0);
+            this.currentSessionSize -= sentSize;
+            this.currentSessionSize = Math.max(0, this.currentSessionSize); // Prevent negative
+            this.activeBatchCount++;
+            try {
+                const batchStartTime = eventsToSend[0]?.timestamp || Date.now();
+                const batchEndTime = eventsToSend[eventsToSend.length - 1]?.timestamp || Date.now();
+                const batchMetadata = {
+                    appId: this.context.appManager.getAppId(),
+                    session_id: this.sessionId,
+                    user_id: this.context.userManager.getUserId(),
+                    start_time: batchStartTime,
+                    end_time: batchEndTime,
+                };
+                // 1. Get S3 URL
+                const addUrl = this.context.api.buildUrl(['sessions', 'add'], batchMetadata);
+                const response = await this.sendRequest(addUrl, null, 'GET', {}, true);
+                if (response.status === 204) {
+                    // Storage exceeded - events already removed from pending, so just log
+                    this.context.logger.warning('Session storage exceeded');
+                    this.isActive = false;
+                    this.context?.setPluginField('isRecordingActive', false);
+                    return;
+                }
+                const s3Url = response.data;
+                // Assuming response.data is the URL string or { url: string }
+                const uploadUrl = typeof s3Url === 'string' ? s3Url : s3Url?.url;
+                if (uploadUrl) {
+                    // 2. Upload to S3
+                    await this.uploadToS3(uploadUrl, eventsToSend);
+                    this.sentEventCount += eventsToSend.length;
+                    this.lastBatchTime = Date.now();
+                }
+                else {
+                    throw new Error('No S3 URL returned');
+                }
+            }
+            catch (error) {
+                this.context?.logger.error('Error sending session batch to backend', {
+                    error: error instanceof Error ? error.message : error,
+                    eventsCount: eventsToSend.length,
+                });
+                // Optionally: re-add events to pending on failure if you want retry logic
+                // this.pendingEvents.push(...eventsToSend);
+                throw error;
+            }
+            finally {
+                this.activeBatchCount--;
+                // Check if there are more events to send after this batch completes
+                if (this.pendingEvents.length > 0) {
+                    this.checkBatchLimits();
+                }
+            }
+        }
+        // MARK: Fetch Delayed URL
+        async fetchDelayedUrl() {
+            if (!this.context)
+                return;
+            try {
+                const appId = this.context.appManager.getAppId();
+                const url = this.context.api.buildUrl(['sessions', 'addDelayed'], {
+                    session_id: this.sessionId,
+                    appId,
+                    user_id: this.context.userManager.getUserId(),
+                });
+                const response = await this.sendRequest(url, null, 'GET');
+                if (response && response.data) {
+                    const data = response.data;
+                    this.delayedS3Url = data.url;
+                    this.delayedUrlTtl = data.ttl;
+                    // Schedule refresh before TTL expires (with 10 second buffer for request time)
+                    this.scheduleDelayedUrlRefresh();
+                }
+            }
+            catch (error) {
+                this.context.logger.error('Failed to fetch delayed URL', { error });
+            }
+        }
+        // MARK: Schedule Delayed URL Refresh
+        scheduleDelayedUrlRefresh() {
+            // Clear existing timer
+            if (this.delayedUrlRefreshTimer) {
+                clearTimeout(this.delayedUrlRefreshTimer);
+            }
+            // Calculate refresh time: TTL minus 10 seconds buffer for request time
+            const bufferTime = 10000; // 10 seconds
+            const refreshTime = Math.max(0, this.delayedUrlTtl - bufferTime);
+            this.delayedUrlRefreshTimer = setTimeout(() => {
+                this.fetchDelayedUrl();
+            }, refreshTime);
+        }
+        // MARK: Send Final Batch
+        async sendFinalBatch() {
+            if (!this.pendingEvents.length || !this.context)
+                return;
+            // Ensure we have a valid delayed URL
+            if (!this.delayedS3Url) {
+                this.context.logger.warning('No delayed URL available, attempting to fetch...');
+                await this.fetchDelayedUrl();
+                if (!this.delayedS3Url) {
+                    this.context.logger.error('Failed to get delayed URL for final batch');
+                    return;
+                }
+            }
+            const eventsToSend = [...this.pendingEvents];
+            this.pendingEvents = []; // Clear immediately
+            this.currentSessionSize = 0; // Reset since all events are sent
+            // Events are already compressed by packFn if compressionEnabled is true
+            const fileContent = JSON.stringify(eventsToSend);
+            const blob = new Blob([fileContent], { type: 'application/json' });
+            // Use fetch with keepalive for page unload reliability
+            // credentials: 'omit' prevents CORS issues with S3 buckets that use wildcard CORS
+            try {
+                const response = await fetch(this.delayedS3Url, {
+                    method: 'PUT',
+                    body: blob,
+                    keepalive: true, // Ensures request continues even if page unloads
+                    credentials: 'omit', // Prevents CORS issues with wildcard Access-Control-Allow-Origin
+                });
+                if (!response.ok) {
+                    throw new Error(`S3 upload failed: ${response.statusText}`);
+                }
+                this.lastBatchTime = Date.now();
+            }
+            catch (error) {
+                this.context.logger.error('Error sending final batch', { error });
+            }
+        }
+        // MARK: Upload To S3
+        async uploadToS3(url, data) {
+            // Events are already compressed by packFn if compressionEnabled is true
+            const body = JSON.stringify(data);
+            // Use native fetch for S3 to avoid SDK headers which might cause issues with presigned URLs
+            const response = await fetch(url, {
+                method: 'PUT', // Usually S3 uploads are PUT
+                body: body,
+            });
+            if (!response.ok) {
+                throw new Error(`S3 upload failed: ${response.statusText}`);
+            }
+        }
+        // MARK: Send Request
+        sendRequest(url, body, method = 'POST', headers = {}, noContentType = false) {
+            return new Promise((resolve, reject) => {
+                if (!this.context)
+                    return reject(new Error('No context'));
+                const request = this.context.api.createRequestStructure(url, body, headers, method);
+                this.context.api.sendRequest(`req-${Date.now()}-${Math.random()}`, request, (status, data, error) => {
+                    if (status >= 200 && status < 300) {
+                        resolve({ status, data });
+                    }
+                    else {
+                        reject({ status, data, error });
+                    }
+                }, { gzip: false, method, noContentType });
+            });
+        }
+    }
+
+    if (typeof window !== 'undefined') {
+        window.D2DWebSessionTracker = D2DWebSessionTracker;
+    }
+
+})();
+//# sourceMappingURL=browser.js.map