@highlight-run/rrweb 2.0.11 → 2.0.15

package/lib/replay/rrweb-replay.js

@@ -2,8 +2,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var rrwebSnapshot = require('@highlight-run/rrweb-snapshot');
-
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -29,6 +27,960 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
+var NodeType$2;
+(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$2 || (NodeType$2 = {}));
+
+function isElement(n) {
+    return n.nodeType === n.ELEMENT_NODE;
+}
+var Mirror$2 = (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) {
+        this.idNodeMap.set(id, n);
+    };
+    Mirror.prototype.reset = function () {
+        this.idNodeMap = new Map();
+        this.nodeMetaMap = new WeakMap();
+    };
+    return Mirror;
+}());
+function createMirror$2() {
+    return new Mirror$2();
+}
+
+var commentre = /\/\*[^*]*\*+([^/*][^*]*\*+)*\//g;
+function parse(css, options) {
+    if (options === void 0) { options = {}; }
+    var lineno = 1;
+    var column = 1;
+    function updatePosition(str) {
+        var lines = str.match(/\n/g);
+        if (lines) {
+            lineno += lines.length;
+        }
+        var i = str.lastIndexOf('\n');
+        column = i === -1 ? column + str.length : str.length - i;
+    }
+    function position() {
+        var start = { line: lineno, column: column };
+        return function (node) {
+            node.position = new Position(start);
+            whitespace();
+            return node;
+        };
+    }
+    var Position = (function () {
+        function Position(start) {
+            this.start = start;
+            this.end = { line: lineno, column: column };
+            this.source = options.source;
+        }
+        return Position;
+    }());
+    Position.prototype.content = css;
+    var errorsList = [];
+    function error(msg) {
+        var err = new Error(options.source + ':' + lineno + ':' + column + ': ' + msg);
+        err.reason = msg;
+        err.filename = options.source;
+        err.line = lineno;
+        err.column = column;
+        err.source = css;
+        if (options.silent) {
+            errorsList.push(err);
+        }
+        else {
+            throw err;
+        }
+    }
+    function stylesheet() {
+        var rulesList = rules();
+        return {
+            type: 'stylesheet',
+            stylesheet: {
+                source: options.source,
+                rules: rulesList,
+                parsingErrors: errorsList
+            }
+        };
+    }
+    function open() {
+        return match(/^{\s*/);
+    }
+    function close() {
+        return match(/^}/);
+    }
+    function rules() {
+        var node;
+        var rules = [];
+        whitespace();
+        comments(rules);
+        while (css.length && css.charAt(0) !== '}' && (node = atrule() || rule())) {
+            if (node !== false) {
+                rules.push(node);
+                comments(rules);
+            }
+        }
+        return rules;
+    }
+    function match(re) {
+        var m = re.exec(css);
+        if (!m) {
+            return;
+        }
+        var str = m[0];
+        updatePosition(str);
+        css = css.slice(str.length);
+        return m;
+    }
+    function whitespace() {
+        match(/^\s*/);
+    }
+    function comments(rules) {
+        if (rules === void 0) { rules = []; }
+        var c;
+        while ((c = comment())) {
+            if (c !== false) {
+                rules.push(c);
+            }
+            c = comment();
+        }
+        return rules;
+    }
+    function comment() {
+        var pos = position();
+        if ('/' !== css.charAt(0) || '*' !== css.charAt(1)) {
+            return;
+        }
+        var i = 2;
+        while ('' !== css.charAt(i) &&
+            ('*' !== css.charAt(i) || '/' !== css.charAt(i + 1))) {
+            ++i;
+        }
+        i += 2;
+        if ('' === css.charAt(i - 1)) {
+            return error('End of comment missing');
+        }
+        var str = css.slice(2, i - 2);
+        column += 2;
+        updatePosition(str);
+        css = css.slice(i);
+        column += 2;
+        return pos({
+            type: 'comment',
+            comment: str
+        });
+    }
+    function selector() {
+        var m = match(/^([^{]+)/);
+        if (!m) {
+            return;
+        }
+        return trim(m[0])
+            .replace(/\/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*\/+/g, '')
+            .replace(/"(?:\\"|[^"])*"|'(?:\\'|[^'])*'/g, function (m) {
+            return m.replace(/,/g, '\u200C');
+        })
+            .split(/\s*(?![^(]*\)),\s*/)
+            .map(function (s) {
+            return s.replace(/\u200C/g, ',');
+        });
+    }
+    function declaration() {
+        var pos = position();
+        var propMatch = match(/^(\*?[-#\/\*\\\w]+(\[[0-9a-z_-]+\])?)\s*/);
+        if (!propMatch) {
+            return;
+        }
+        var prop = trim(propMatch[0]);
+        if (!match(/^:\s*/)) {
+            return error("property missing ':'");
+        }
+        var val = match(/^((?:'(?:\\'|.)*?'|"(?:\\"|.)*?"|\([^\)]*?\)|[^};])+)/);
+        var ret = pos({
+            type: 'declaration',
+            property: prop.replace(commentre, ''),
+            value: val ? trim(val[0]).replace(commentre, '') : ''
+        });
+        match(/^[;\s]*/);
+        return ret;
+    }
+    function declarations() {
+        var decls = [];
+        if (!open()) {
+            return error("missing '{'");
+        }
+        comments(decls);
+        var decl;
+        while ((decl = declaration())) {
+            if (decl !== false) {
+                decls.push(decl);
+                comments(decls);
+            }
+            decl = declaration();
+        }
+        if (!close()) {
+            return error("missing '}'");
+        }
+        return decls;
+    }
+    function keyframe() {
+        var m;
+        var vals = [];
+        var pos = position();
+        while ((m = match(/^((\d+\.\d+|\.\d+|\d+)%?|[a-z]+)\s*/))) {
+            vals.push(m[1]);
+            match(/^,\s*/);
+        }
+        if (!vals.length) {
+            return;
+        }
+        return pos({
+            type: 'keyframe',
+            values: vals,
+            declarations: declarations()
+        });
+    }
+    function atkeyframes() {
+        var pos = position();
+        var m = match(/^@([-\w]+)?keyframes\s*/);
+        if (!m) {
+            return;
+        }
+        var vendor = m[1];
+        m = match(/^([-\w]+)\s*/);
+        if (!m) {
+            return error('@keyframes missing name');
+        }
+        var name = m[1];
+        if (!open()) {
+            return error("@keyframes missing '{'");
+        }
+        var frame;
+        var frames = comments();
+        while ((frame = keyframe())) {
+            frames.push(frame);
+            frames = frames.concat(comments());
+        }
+        if (!close()) {
+            return error("@keyframes missing '}'");
+        }
+        return pos({
+            type: 'keyframes',
+            name: name,
+            vendor: vendor,
+            keyframes: frames
+        });
+    }
+    function atsupports() {
+        var pos = position();
+        var m = match(/^@supports *([^{]+)/);
+        if (!m) {
+            return;
+        }
+        var supports = trim(m[1]);
+        if (!open()) {
+            return error("@supports missing '{'");
+        }
+        var style = comments().concat(rules());
+        if (!close()) {
+            return error("@supports missing '}'");
+        }
+        return pos({
+            type: 'supports',
+            supports: supports,
+            rules: style
+        });
+    }
+    function athost() {
+        var pos = position();
+        var m = match(/^@host\s*/);
+        if (!m) {
+            return;
+        }
+        if (!open()) {
+            return error("@host missing '{'");
+        }
+        var style = comments().concat(rules());
+        if (!close()) {
+            return error("@host missing '}'");
+        }
+        return pos({
+            type: 'host',
+            rules: style
+        });
+    }
+    function atmedia() {
+        var pos = position();
+        var m = match(/^@media *([^{]+)/);
+        if (!m) {
+            return;
+        }
+        var media = trim(m[1]);
+        if (!open()) {
+            return error("@media missing '{'");
+        }
+        var style = comments().concat(rules());
+        if (!close()) {
+            return error("@media missing '}'");
+        }
+        return pos({
+            type: 'media',
+            media: media,
+            rules: style
+        });
+    }
+    function atcustommedia() {
+        var pos = position();
+        var m = match(/^@custom-media\s+(--[^\s]+)\s*([^{;]+);/);
+        if (!m) {
+            return;
+        }
+        return pos({
+            type: 'custom-media',
+            name: trim(m[1]),
+            media: trim(m[2])
+        });
+    }
+    function atpage() {
+        var pos = position();
+        var m = match(/^@page */);
+        if (!m) {
+            return;
+        }
+        var sel = selector() || [];
+        if (!open()) {
+            return error("@page missing '{'");
+        }
+        var decls = comments();
+        var decl;
+        while ((decl = declaration())) {
+            decls.push(decl);
+            decls = decls.concat(comments());
+        }
+        if (!close()) {
+            return error("@page missing '}'");
+        }
+        return pos({
+            type: 'page',
+            selectors: sel,
+            declarations: decls
+        });
+    }
+    function atdocument() {
+        var pos = position();
+        var m = match(/^@([-\w]+)?document *([^{]+)/);
+        if (!m) {
+            return;
+        }
+        var vendor = trim(m[1]);
+        var doc = trim(m[2]);
+        if (!open()) {
+            return error("@document missing '{'");
+        }
+        var style = comments().concat(rules());
+        if (!close()) {
+            return error("@document missing '}'");
+        }
+        return pos({
+            type: 'document',
+            document: doc,
+            vendor: vendor,
+            rules: style
+        });
+    }
+    function atfontface() {
+        var pos = position();
+        var m = match(/^@font-face\s*/);
+        if (!m) {
+            return;
+        }
+        if (!open()) {
+            return error("@font-face missing '{'");
+        }
+        var decls = comments();
+        var decl;
+        while ((decl = declaration())) {
+            decls.push(decl);
+            decls = decls.concat(comments());
+        }
+        if (!close()) {
+            return error("@font-face missing '}'");
+        }
+        return pos({
+            type: 'font-face',
+            declarations: decls
+        });
+    }
+    var atimport = _compileAtrule('import');
+    var atcharset = _compileAtrule('charset');
+    var atnamespace = _compileAtrule('namespace');
+    function _compileAtrule(name) {
+        var re = new RegExp('^@' + name + '\\s*([^;]+);');
+        return function () {
+            var pos = position();
+            var m = match(re);
+            if (!m) {
+                return;
+            }
+            var ret = { type: name };
+            ret[name] = m[1].trim();
+            return pos(ret);
+        };
+    }
+    function atrule() {
+        if (css[0] !== '@') {
+            return;
+        }
+        return (atkeyframes() ||
+            atmedia() ||
+            atcustommedia() ||
+            atsupports() ||
+            atimport() ||
+            atcharset() ||
+            atnamespace() ||
+            atdocument() ||
+            atpage() ||
+            athost() ||
+            atfontface());
+    }
+    function rule() {
+        var pos = position();
+        var sel = selector();
+        if (!sel) {
+            return error('selector missing');
+        }
+        comments();
+        return pos({
+            type: 'rule',
+            selectors: sel,
+            declarations: declarations()
+        });
+    }
+    return addParent(stylesheet());
+}
+function trim(str) {
+    return str ? str.replace(/^\s+|\s+$/g, '') : '';
+}
+function addParent(obj, parent) {
+    var isNode = obj && typeof obj.type === 'string';
+    var childParent = isNode ? obj : parent;
+    for (var _i = 0, _a = Object.keys(obj); _i < _a.length; _i++) {
+        var k = _a[_i];
+        var value = obj[k];
+        if (Array.isArray(value)) {
+            value.forEach(function (v) {
+                addParent(v, childParent);
+            });
+        }
+        else if (value && typeof value === 'object') {
+            addParent(value, childParent);
+        }
+    }
+    if (isNode) {
+        Object.defineProperty(obj, 'parent', {
+            configurable: true,
+            writable: true,
+            enumerable: false,
+            value: parent || null
+        });
+    }
+    return obj;
+}
+
+var tagMap = {
+    script: 'noscript',
+    altglyph: 'altGlyph',
+    altglyphdef: 'altGlyphDef',
+    altglyphitem: 'altGlyphItem',
+    animatecolor: 'animateColor',
+    animatemotion: 'animateMotion',
+    animatetransform: 'animateTransform',
+    clippath: 'clipPath',
+    feblend: 'feBlend',
+    fecolormatrix: 'feColorMatrix',
+    fecomponenttransfer: 'feComponentTransfer',
+    fecomposite: 'feComposite',
+    feconvolvematrix: 'feConvolveMatrix',
+    fediffuselighting: 'feDiffuseLighting',
+    fedisplacementmap: 'feDisplacementMap',
+    fedistantlight: 'feDistantLight',
+    fedropshadow: 'feDropShadow',
+    feflood: 'feFlood',
+    fefunca: 'feFuncA',
+    fefuncb: 'feFuncB',
+    fefuncg: 'feFuncG',
+    fefuncr: 'feFuncR',
+    fegaussianblur: 'feGaussianBlur',
+    feimage: 'feImage',
+    femerge: 'feMerge',
+    femergenode: 'feMergeNode',
+    femorphology: 'feMorphology',
+    feoffset: 'feOffset',
+    fepointlight: 'fePointLight',
+    fespecularlighting: 'feSpecularLighting',
+    fespotlight: 'feSpotLight',
+    fetile: 'feTile',
+    feturbulence: 'feTurbulence',
+    foreignobject: 'foreignObject',
+    glyphref: 'glyphRef',
+    lineargradient: 'linearGradient',
+    radialgradient: 'radialGradient'
+};
+function getTagName(n) {
+    var tagName = tagMap[n.tagName] ? tagMap[n.tagName] : n.tagName;
+    if (tagName === 'link' && n.attributes._cssText) {
+        tagName = 'style';
+    }
+    return tagName;
+}
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+var HOVER_SELECTOR = /([^\\]):hover/;
+var HOVER_SELECTOR_GLOBAL = new RegExp(HOVER_SELECTOR.source, 'g');
+function addHoverClass(cssText, cache) {
+    var _a;
+    if (!((_a = window === null || window === void 0 ? void 0 : window.HIG_CONFIGURATION) === null || _a === void 0 ? void 0 : _a.enableOnHoverClass)) {
+        return cssText;
+    }
+    var cachedStyle = cache === null || cache === void 0 ? void 0 : cache.stylesWithHoverClass.get(cssText);
+    if (cachedStyle)
+        return cachedStyle;
+    var ast = parse(cssText, {
+        silent: true
+    });
+    if (!ast.stylesheet) {
+        return cssText;
+    }
+    var selectors = [];
+    ast.stylesheet.rules.forEach(function (rule) {
+        if ('selectors' in rule) {
+            (rule.selectors || []).forEach(function (selector) {
+                if (HOVER_SELECTOR.test(selector)) {
+                    selectors.push(selector);
+                }
+            });
+        }
+    });
+    if (selectors.length === 0) {
+        return cssText;
+    }
+    var selectorMatcher = new RegExp(selectors
+        .filter(function (selector, index) { return selectors.indexOf(selector) === index; })
+        .sort(function (a, b) { return b.length - a.length; })
+        .map(function (selector) {
+        return escapeRegExp(selector);
+    })
+        .join('|'), 'g');
+    var result = cssText.replace(selectorMatcher, function (selector) {
+        var newSelector = selector.replace(HOVER_SELECTOR_GLOBAL, '$1.\\:hover');
+        return "".concat(selector, ", ").concat(newSelector);
+    });
+    cache === null || cache === void 0 ? void 0 : cache.stylesWithHoverClass.set(cssText, result);
+    return result;
+}
+function createCache() {
+    var stylesWithHoverClass = new Map();
+    return {
+        stylesWithHoverClass: stylesWithHoverClass
+    };
+}
+function buildNode(n, options) {
+    var doc = options.doc, hackCss = options.hackCss, cache = options.cache;
+    switch (n.type) {
+        case NodeType$2.Document:
+            return doc.implementation.createDocument(null, '', null);
+        case NodeType$2.DocumentType:
+            return doc.implementation.createDocumentType(n.name || 'html', n.publicId, n.systemId);
+        case NodeType$2.Element:
+            var tagName = getTagName(n);
+            var node_1;
+            if (n.isSVG) {
+                node_1 = doc.createElementNS('http://www.w3.org/2000/svg', tagName);
+            }
+            else {
+                node_1 = doc.createElement(tagName);
+            }
+            var _loop_1 = function (name_1) {
+                if (!n.attributes.hasOwnProperty(name_1)) {
+                    return "continue";
+                }
+                var value = n.attributes[name_1];
+                if (tagName === 'option' && name_1 === 'selected' && value === false) {
+                    return "continue";
+                }
+                value =
+                    typeof value === 'boolean' || typeof value === 'number' ? '' : value;
+                if (!name_1.startsWith('rr_')) {
+                    var isTextarea = tagName === 'textarea' && name_1 === 'value';
+                    var isRemoteOrDynamicCss = tagName === 'style' && name_1 === '_cssText';
+                    if (isRemoteOrDynamicCss && hackCss) {
+                        value = addHoverClass(value, cache);
+                        if (typeof value === 'string') {
+                            var regex = /url\(\"https:\/\/\S*(.eot|.woff2|.ttf|.woff)\S*\"\)/gm;
+                            var m = void 0;
+                            var fontUrls_1 = [];
+                            var PROXY_URL_1 = 'https://replay-cors-proxy.highlightrun.workers.dev';
+                            while ((m = regex.exec(value)) !== null) {
+                                if (m.index === regex.lastIndex) {
+                                    regex.lastIndex++;
+                                }
+                                m.forEach(function (match, groupIndex) {
+                                    if (groupIndex === 0) {
+                                        var url = match.slice(5, match.length - 2);
+                                        fontUrls_1.push({
+                                            originalUrl: url,
+                                            proxyUrl: url.replace(url, "".concat(PROXY_URL_1, "?url=").concat(url))
+                                        });
+                                    }
+                                });
+                            }
+                            fontUrls_1.forEach(function (urlPair) {
+                                value = value.replace(urlPair.originalUrl, urlPair.proxyUrl);
+                            });
+                        }
+                    }
+                    if (isTextarea || isRemoteOrDynamicCss) {
+                        var child = doc.createTextNode(value);
+                        for (var _i = 0, _a = Array.from(node_1.childNodes); _i < _a.length; _i++) {
+                            var c = _a[_i];
+                            if (c.nodeType === node_1.TEXT_NODE) {
+                                node_1.removeChild(c);
+                            }
+                        }
+                        node_1.appendChild(child);
+                        return "continue";
+                    }
+                    try {
+                        if (n.isSVG && name_1 === 'xlink:href') {
+                            node_1.setAttributeNS('http://www.w3.org/1999/xlink', name_1, value);
+                        }
+                        else if (name_1 === 'onload' ||
+                            name_1 === 'onclick' ||
+                            name_1.substring(0, 7) === 'onmouse') {
+                            node_1.setAttribute('_' + name_1, value);
+                        }
+                        else if (tagName === 'meta' &&
+                            n.attributes['http-equiv'] === 'Content-Security-Policy' &&
+                            name_1 === 'content') {
+                            node_1.setAttribute('csp-content', value);
+                            return "continue";
+                        }
+                        else if (tagName === 'link' &&
+                            n.attributes.rel === 'preload' &&
+                            n.attributes.as === 'script') {
+                        }
+                        else if (tagName === 'link' &&
+                            n.attributes.rel === 'prefetch' &&
+                            typeof n.attributes.href === 'string' &&
+                            n.attributes.href.endsWith('.js')) {
+                        }
+                        else if (tagName === 'img' &&
+                            n.attributes.srcset &&
+                            n.attributes.rr_dataURL) {
+                            node_1.setAttribute('rrweb-original-srcset', n.attributes.srcset);
+                        }
+                        else {
+                            node_1.setAttribute(name_1, value);
+                        }
+                    }
+                    catch (error) {
+                    }
+                }
+                else {
+                    if (tagName === 'canvas' && name_1 === 'rr_dataURL') {
+                        var image_1 = document.createElement('img');
+                        image_1.src = value;
+                        image_1.onload = function () {
+                            var ctx = node_1.getContext('2d');
+                            if (ctx) {
+                                ctx.drawImage(image_1, 0, 0, image_1.width, image_1.height);
+                            }
+                        };
+                    }
+                    else if (tagName === 'img' && name_1 === 'rr_dataURL') {
+                        var image = node_1;
+                        if (!image.currentSrc.startsWith('data:')) {
+                            image.setAttribute('rrweb-original-src', n.attributes.src);
+                            image.src = value;
+                            image.setAttribute('rrweb-inline-src', value);
+                        }
+                    }
+                    if (name_1 === 'rr_width') {
+                        node_1.style.width = value;
+                    }
+                    else if (name_1 === 'rr_height') {
+                        node_1.style.height = value;
+                    }
+                    else if (name_1 === 'rr_mediaCurrentTime') {
+                        node_1.currentTime = n.attributes
+                            .rr_mediaCurrentTime;
+                    }
+                    else if (name_1 === 'rr_mediaState') {
+                        switch (value) {
+                            case 'played':
+                                node_1
+                                    .play()["catch"](function (e) { return console.warn('media playback error', e); });
+                                break;
+                            case 'paused':
+                                node_1.pause();
+                                break;
+                        }
+                    }
+                }
+            };
+            for (var name_1 in n.attributes) {
+                _loop_1(name_1);
+            }
+            if (tagName === 'img') {
+                var image = node_1;
+                if (!image.currentSrc.startsWith('data:')) {
+                    var inlineSrc = image.getAttribute('rrweb-inline-src');
+                    if (inlineSrc === null || inlineSrc === void 0 ? void 0 : inlineSrc.startsWith('data:')) {
+                        image.src = inlineSrc;
+                    }
+                }
+            }
+            if (n.isShadowHost) {
+                if (!node_1.shadowRoot) {
+                    node_1.attachShadow({ mode: 'open' });
+                }
+                else {
+                    while (node_1.shadowRoot.firstChild) {
+                        node_1.shadowRoot.removeChild(node_1.shadowRoot.firstChild);
+                    }
+                }
+            }
+            return node_1;
+        case NodeType$2.Text:
+            return doc.createTextNode(n.isStyle && hackCss
+                ? addHoverClass(n.textContent, cache)
+                : n.textContent);
+        case NodeType$2.CDATA:
+            return doc.createCDATASection(n.textContent);
+        case NodeType$2.Comment:
+            return doc.createComment(n.textContent);
+        default:
+            return null;
+    }
+}
+function buildNodeWithSN(n, options) {
+    var doc = options.doc, mirror = options.mirror, _a = options.skipChild, skipChild = _a === void 0 ? false : _a, _b = options.hackCss, hackCss = _b === void 0 ? true : _b, afterAppend = options.afterAppend, cache = options.cache;
+    var node = buildNode(n, { doc: doc, hackCss: hackCss, cache: cache });
+    if (!node) {
+        return null;
+    }
+    if (n.rootId) {
+        console.assert(mirror.getNode(n.rootId) === doc, 'Target document should have the same root id.');
+    }
+    if (n.type === NodeType$2.Document) {
+        doc.close();
+        doc.open();
+        if (n.compatMode === 'BackCompat' &&
+            n.childNodes &&
+            n.childNodes[0].type !== NodeType$2.DocumentType) {
+            if (n.childNodes[0].type === NodeType$2.Element &&
+                'xmlns' in n.childNodes[0].attributes &&
+                n.childNodes[0].attributes.xmlns === 'http://www.w3.org/1999/xhtml') {
+                doc.write('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "">');
+            }
+            else {
+                doc.write('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "">');
+            }
+        }
+        node = doc;
+    }
+    mirror.add(node, n);
+    if ((n.type === NodeType$2.Document || n.type === NodeType$2.Element) &&
+        !skipChild) {
+        for (var _i = 0, _c = n.childNodes; _i < _c.length; _i++) {
+            var childN = _c[_i];
+            var childNode = buildNodeWithSN(childN, {
+                doc: doc,
+                mirror: mirror,
+                skipChild: false,
+                hackCss: hackCss,
+                afterAppend: afterAppend,
+                cache: cache
+            });
+            if (!childNode) {
+                console.warn('Failed to rebuild', childN);
+                continue;
+            }
+            if (childN.isShadow && isElement(node) && node.shadowRoot) {
+                node.shadowRoot.appendChild(childNode);
+            }
+            else {
+                node.appendChild(childNode);
+            }
+            if (afterAppend) {
+                afterAppend(childNode);
+            }
+        }
+    }
+    return node;
+}
+function visit(mirror, onVisit) {
+    function walk(node) {
+        onVisit(node);
+    }
+    for (var _i = 0, _a = mirror.getIds(); _i < _a.length; _i++) {
+        var id = _a[_i];
+        if (mirror.has(id)) {
+            walk(mirror.getNode(id));
+        }
+    }
+}
+function handleScroll(node, mirror) {
+    var n = mirror.getMeta(node);
+    if ((n === null || n === void 0 ? void 0 : n.type) !== NodeType$2.Element) {
+        return;
+    }
+    var el = node;
+    for (var name_2 in n.attributes) {
+        if (!(n.attributes.hasOwnProperty(name_2) && name_2.startsWith('rr_'))) {
+            continue;
+        }
+        var value = n.attributes[name_2];
+        if (name_2 === 'rr_scrollLeft') {
+            el.scrollLeft = value;
+        }
+        if (name_2 === 'rr_scrollTop') {
+            el.scrollTop = value;
+        }
+    }
+}
+function rebuild(n, options) {
+    var doc = options.doc, onVisit = options.onVisit, _a = options.hackCss, hackCss = _a === void 0 ? true : _a, afterAppend = options.afterAppend, cache = options.cache, _b = options.mirror, mirror = _b === void 0 ? new Mirror$2() : _b;
+    var node = buildNodeWithSN(n, {
+        doc: doc,
+        mirror: mirror,
+        skipChild: false,
+        hackCss: hackCss,
+        afterAppend: afterAppend,
+        cache: cache
+    });
+    visit(mirror, function (visitedNode) {
+        if (onVisit) {
+            onVisit(visitedNode);
+        }
+        handleScroll(visitedNode, mirror);
+    });
+    return node;
+}
+
+var NodeType$1;
+(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$1 || (NodeType$1 = {}));
+var Mirror$1 = (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) {
+        this.idNodeMap.set(id, n);
+    };
+    Mirror.prototype.reset = function () {
+        this.idNodeMap = new Map();
+        this.nodeMetaMap = new WeakMap();
+    };
+    return Mirror;
+}());
+function createMirror$1() {
+    return new Mirror$1();
+}
+
 function parseCSSText(cssText) {
     const res = {};
     const listDelimiter = /;(?![^(]*\))/g;
@@ -119,21 +1071,21 @@ function BaseRRDocumentImpl(RRNodeClass) {
             this.nodeType = NodeType.DOCUMENT_NODE;
             this.nodeName = '#document';
             this.compatMode = 'CSS1Compat';
-            this.RRNodeType = rrwebSnapshot.NodeType.Document;
+            this.RRNodeType = NodeType$1.Document;
             this.textContent = null;
         }
         get documentElement() {
-            return (this.childNodes.find((node) => node.RRNodeType === rrwebSnapshot.NodeType.Element &&
+            return (this.childNodes.find((node) => node.RRNodeType === NodeType$1.Element &&
                 node.tagName === 'HTML') || null);
         }
         get body() {
             var _a;
-            return (((_a = this.documentElement) === null || _a === void 0 ? void 0 : _a.childNodes.find((node) => node.RRNodeType === rrwebSnapshot.NodeType.Element &&
+            return (((_a = this.documentElement) === null || _a === void 0 ? void 0 : _a.childNodes.find((node) => node.RRNodeType === NodeType$1.Element &&
                 node.tagName === 'BODY')) || null);
         }
         get head() {
             var _a;
-            return (((_a = this.documentElement) === null || _a === void 0 ? void 0 : _a.childNodes.find((node) => node.RRNodeType === rrwebSnapshot.NodeType.Element &&
+            return (((_a = this.documentElement) === null || _a === void 0 ? void 0 : _a.childNodes.find((node) => node.RRNodeType === NodeType$1.Element &&
                 node.tagName === 'HEAD')) || null);
         }
         get implementation() {
@@ -144,10 +1096,10 @@ function BaseRRDocumentImpl(RRNodeClass) {
         }
         appendChild(childNode) {
             const nodeType = childNode.RRNodeType;
-            if (nodeType === rrwebSnapshot.NodeType.Element ||
-                nodeType === rrwebSnapshot.NodeType.DocumentType) {
+            if (nodeType === NodeType$1.Element ||
+                nodeType === NodeType$1.DocumentType) {
                 if (this.childNodes.some((s) => s.RRNodeType === nodeType)) {
-                    throw new Error(`RRDomException: Failed to execute 'appendChild' on 'RRNode': Only one ${nodeType === rrwebSnapshot.NodeType.Element ? 'RRElement' : 'RRDoctype'} on RRDocument allowed.`);
+                    throw new Error(`RRDomException: Failed to execute 'appendChild' on 'RRNode': Only one ${nodeType === NodeType$1.Element ? 'RRElement' : 'RRDoctype'} on RRDocument allowed.`);
                 }
             }
             childNode.parentElement = null;
@@ -157,10 +1109,10 @@ function BaseRRDocumentImpl(RRNodeClass) {
         }
         insertBefore(newChild, refChild) {
             const nodeType = newChild.RRNodeType;
-            if (nodeType === rrwebSnapshot.NodeType.Element ||
-                nodeType === rrwebSnapshot.NodeType.DocumentType) {
+            if (nodeType === NodeType$1.Element ||
+                nodeType === NodeType$1.DocumentType) {
                 if (this.childNodes.some((s) => s.RRNodeType === nodeType)) {
-                    throw new Error(`RRDomException: Failed to execute 'insertBefore' on 'RRNode': Only one ${nodeType === rrwebSnapshot.NodeType.Element ? 'RRElement' : 'RRDoctype'} on RRDocument allowed.`);
+                    throw new Error(`RRDomException: Failed to execute 'insertBefore' on 'RRNode': Only one ${nodeType === NodeType$1.Element ? 'RRElement' : 'RRDoctype'} on RRDocument allowed.`);
                 }
             }
             if (refChild === null)
@@ -242,7 +1194,7 @@ function BaseRRDocumentTypeImpl(RRNodeClass) {
         constructor(qualifiedName, publicId, systemId) {
             super();
             this.nodeType = NodeType.DOCUMENT_TYPE_NODE;
-            this.RRNodeType = rrwebSnapshot.NodeType.DocumentType;
+            this.RRNodeType = NodeType$1.DocumentType;
             this.textContent = null;
             this.name = qualifiedName;
             this.publicId = publicId;
@@ -259,7 +1211,7 @@ function BaseRRElementImpl(RRNodeClass) {
         constructor(tagName) {
             super();
             this.nodeType = NodeType.ELEMENT_NODE;
-            this.RRNodeType = rrwebSnapshot.NodeType.Element;
+            this.RRNodeType = NodeType$1.Element;
             this.attributes = {};
             this.shadowRoot = null;
             this.tagName = tagName.toUpperCase();
@@ -386,7 +1338,7 @@ function BaseRRTextImpl(RRNodeClass) {
             super();
             this.nodeType = NodeType.TEXT_NODE;
             this.nodeName = '#text';
-            this.RRNodeType = rrwebSnapshot.NodeType.Text;
+            this.RRNodeType = NodeType$1.Text;
             this.data = data;
         }
         get textContent() {
@@ -406,7 +1358,7 @@ function BaseRRCommentImpl(RRNodeClass) {
             super();
             this.nodeType = NodeType.COMMENT_NODE;
             this.nodeName = '#comment';
-            this.RRNodeType = rrwebSnapshot.NodeType.Comment;
+            this.RRNodeType = NodeType$1.Comment;
             this.data = data;
         }
         get textContent() {
@@ -426,7 +1378,7 @@ function BaseRRCDATASectionImpl(RRNodeClass) {
             super();
             this.nodeName = '#cdata-section';
             this.nodeType = NodeType.CDATA_SECTION_NODE;
-            this.RRNodeType = rrwebSnapshot.NodeType.CDATA;
+            this.RRNodeType = NodeType$1.CDATA;
             this.data = data;
         }
         get textContent() {
@@ -496,12 +1448,12 @@ function diff(oldTree, newTree, replayer, rrnodeMirror) {
     }
     let inputDataToApply = null, scrollDataToApply = null;
     switch (newTree.RRNodeType) {
-        case rrwebSnapshot.NodeType.Document: {
+        case NodeType$1.Document: {
             const newRRDocument = newTree;
             scrollDataToApply = newRRDocument.scrollData;
             break;
         }
-        case rrwebSnapshot.NodeType.Element: {
+        case NodeType$1.Element: {
             const oldElement = oldTree;
             const newRRElement = newTree;
             diffProps(oldElement, newRRElement, rrnodeMirror);
@@ -541,9 +1493,9 @@ function diff(oldTree, newTree, replayer, rrnodeMirror) {
             }
             break;
         }
-        case rrwebSnapshot.NodeType.Text:
-        case rrwebSnapshot.NodeType.Comment:
-        case rrwebSnapshot.NodeType.CDATA:
+        case NodeType$1.Text:
+        case NodeType$1.Comment:
+        case NodeType$1.CDATA:
             if (oldTree.textContent !==
                 newTree.data)
                 oldTree.textContent = newTree.data;
@@ -613,26 +1565,16 @@ function diffChildren(oldChildren, newChildren, parentNode, replayer, rrnodeMirr
             newEndNode = newChildren[--newEndIndex];
         }
         else if (replayer.mirror.getId(oldStartNode) === rrnodeMirror.getId(newEndNode)) {
-            try {
-                parentNode.insertBefore(oldStartNode, oldEndNode.nextSibling);
-                diff(oldStartNode, newEndNode, replayer, rrnodeMirror);
-                oldStartNode = oldChildren[++oldStartIndex];
-                newEndNode = newChildren[--newEndIndex];
-            }
-            catch (e) {
-                console.error(e, parentNode, oldStartNode, oldEndNode);
-            }
+            parentNode.insertBefore(oldStartNode, oldEndNode.nextSibling);
+            diff(oldStartNode, newEndNode, replayer, rrnodeMirror);
+            oldStartNode = oldChildren[++oldStartIndex];
+            newEndNode = newChildren[--newEndIndex];
         }
         else if (replayer.mirror.getId(oldEndNode) === rrnodeMirror.getId(newStartNode)) {
-            try {
-                parentNode.insertBefore(oldEndNode, oldStartNode);
-                diff(oldEndNode, newStartNode, replayer, rrnodeMirror);
-                oldEndNode = oldChildren[--oldEndIndex];
-                newStartNode = newChildren[++newStartIndex];
-            }
-            catch (e) {
-                console.error(e, parentNode, oldEndNode, oldStartNode);
-            }
+            parentNode.insertBefore(oldEndNode, oldStartNode);
+            diff(oldEndNode, newStartNode, replayer, rrnodeMirror);
+            oldEndNode = oldChildren[--oldEndIndex];
+            newStartNode = newChildren[++newStartIndex];
         }
         else {
             if (!oldIdToIndex) {
@@ -646,31 +1588,21 @@ function diffChildren(oldChildren, newChildren, parentNode, replayer, rrnodeMirr
             indexInOld = oldIdToIndex[rrnodeMirror.getId(newStartNode)];
             if (indexInOld) {
                 const nodeToMove = oldChildren[indexInOld];
-                try {
-                    parentNode.insertBefore(nodeToMove, oldStartNode);
-                    diff(nodeToMove, newStartNode, replayer, rrnodeMirror);
-                    oldChildren[indexInOld] = undefined;
-                }
-                catch (e) {
-                    console.error(e, parentNode, nodeToMove, oldStartNode);
-                }
+                parentNode.insertBefore(nodeToMove, oldStartNode);
+                diff(nodeToMove, newStartNode, replayer, rrnodeMirror);
+                oldChildren[indexInOld] = undefined;
             }
             else {
                 const newNode = createOrGetNode(newStartNode, replayer.mirror, rrnodeMirror);
                 if (parentNode.nodeName === '#document' &&
-                    ((_a = replayer.mirror.getMeta(newNode)) === null || _a === void 0 ? void 0 : _a.type) === rrwebSnapshot.NodeType.Element &&
+                    ((_a = replayer.mirror.getMeta(newNode)) === null || _a === void 0 ? void 0 : _a.type) === NodeType$1.Element &&
                     parentNode.documentElement) {
                     parentNode.removeChild(parentNode.documentElement);
                     oldChildren[oldStartIndex] = undefined;
                     oldStartNode = undefined;
                 }
-                try {
-                    parentNode.insertBefore(newNode, oldStartNode || null);
-                    diff(newNode, newStartNode, replayer, rrnodeMirror);
-                }
-                catch (e) {
-                    console.error(e, parentNode, newNode, oldStartNode || null);
-                }
+                parentNode.insertBefore(newNode, oldStartNode || null);
+                diff(newNode, newStartNode, replayer, rrnodeMirror);
             }
             newStartNode = newChildren[++newStartIndex];
         }
@@ -685,13 +1617,8 @@ function diffChildren(oldChildren, newChildren, parentNode, replayer, rrnodeMirr
             });
         for (; newStartIndex <= newEndIndex; ++newStartIndex) {
             const newNode = createOrGetNode(newChildren[newStartIndex], replayer.mirror, rrnodeMirror);
-            try {
-                parentNode.insertBefore(newNode, referenceNode);
-                diff(newNode, newChildren[newStartIndex], replayer, rrnodeMirror);
-            }
-            catch (e) {
-                console.error(e, parentNode, newNode, referenceNode);
-            }
+            parentNode.insertBefore(newNode, referenceNode);
+            diff(newNode, newChildren[newStartIndex], replayer, rrnodeMirror);
         }
     }
     else if (newStartIndex > newEndIndex) {
@@ -710,13 +1637,13 @@ function createOrGetNode(rrNode, domMirror, rrnodeMirror) {
     if (node !== null)
         return node;
     switch (rrNode.RRNodeType) {
-        case rrwebSnapshot.NodeType.Document:
+        case NodeType$1.Document:
             node = new Document();
             break;
-        case rrwebSnapshot.NodeType.DocumentType:
+        case NodeType$1.DocumentType:
             node = document.implementation.createDocumentType(rrNode.name, rrNode.publicId, rrNode.systemId);
             break;
-        case rrwebSnapshot.NodeType.Element: {
+        case NodeType$1.Element: {
             rrNode.tagName.toLowerCase();
             if (sn && 'isSVG' in sn && (sn === null || sn === void 0 ? void 0 : sn.isSVG)) {
                 node = document.createElementNS(NAMESPACES['svg'], rrNode.tagName.toLowerCase());
@@ -725,13 +1652,13 @@ function createOrGetNode(rrNode, domMirror, rrnodeMirror) {
                 node = document.createElement(rrNode.tagName);
             break;
         }
-        case rrwebSnapshot.NodeType.Text:
+        case NodeType$1.Text:
             node = document.createTextNode(rrNode.data);
             break;
-        case rrwebSnapshot.NodeType.Comment:
+        case NodeType$1.Comment:
             node = document.createComment(rrNode.data);
             break;
-        case rrwebSnapshot.NodeType.CDATA:
+        case NodeType$1.CDATA:
             node = document.createCDATASection(rrNode.data);
             break;
     }
@@ -925,11 +1852,11 @@ function buildFromNode(node, rrdom, domMirror, parentRRNode) {
             }
             break;
         case NodeType.DOCUMENT_TYPE_NODE:
-            const documentType = (node);
+            const documentType = node;
             rrNode = rrdom.createDocumentType(documentType.name, documentType.publicId, documentType.systemId);
             break;
         case NodeType.ELEMENT_NODE:
-            const elementNode = (node);
+            const elementNode = node;
             const tagName = getValidTagName(elementNode);
             rrNode = rrdom.createElement(tagName);
             const rrElement = rrNode;
@@ -940,13 +1867,13 @@ function buildFromNode(node, rrdom, domMirror, parentRRNode) {
             elementNode.scrollTop && (rrElement.scrollTop = elementNode.scrollTop);
             break;
         case NodeType.TEXT_NODE:
-            rrNode = rrdom.createTextNode((node).textContent || '');
+            rrNode = rrdom.createTextNode(node.textContent || '');
             break;
         case NodeType.CDATA_SECTION_NODE:
-            rrNode = rrdom.createCDATASection((node).data);
+            rrNode = rrdom.createCDATASection(node.data);
             break;
         case NodeType.COMMENT_NODE:
-            rrNode = rrdom.createComment((node).textContent || '');
+            rrNode = rrdom.createComment(node.textContent || '');
             break;
         case NodeType.DOCUMENT_FRAGMENT_NODE:
             rrNode = parentRRNode.attachShadow({ mode: 'open' });
@@ -964,7 +1891,7 @@ function buildFromNode(node, rrdom, domMirror, parentRRNode) {
     }
     return rrNode;
 }
-function buildFromDom(dom, domMirror = rrwebSnapshot.createMirror(), rrdom = new RRDocument()) {
+function buildFromDom(dom, domMirror = createMirror$1(), rrdom = new RRDocument()) {
     function walk(node, parentRRNode) {
         const rrNode = buildFromNode(node, rrdom, domMirror, parentRRNode);
         if (rrNode === null)
@@ -982,8 +1909,8 @@ function buildFromDom(dom, domMirror = rrwebSnapshot.createMirror(), rrdom = new
             node.nodeType === NodeType.ELEMENT_NODE ||
             node.nodeType === NodeType.DOCUMENT_FRAGMENT_NODE) {
             if (node.nodeType === NodeType.ELEMENT_NODE &&
-                (node).shadowRoot)
-                walk((node).shadowRoot, rrNode);
+                node.shadowRoot)
+                walk(node.shadowRoot, rrNode);
             node.childNodes.forEach((childNode) => walk(childNode, rrNode));
         }
     }
@@ -1042,13 +1969,13 @@ class Mirror {
 }
 function getDefaultSN(node, id) {
     switch (node.RRNodeType) {
-        case rrwebSnapshot.NodeType.Document:
+        case NodeType$1.Document:
             return {
                 id,
                 type: node.RRNodeType,
                 childNodes: [],
             };
-        case rrwebSnapshot.NodeType.DocumentType:
+        case NodeType$1.DocumentType:
             const doctype = node;
             return {
                 id,
@@ -1057,7 +1984,7 @@ function getDefaultSN(node, id) {
                 publicId: doctype.publicId,
                 systemId: doctype.systemId,
             };
-        case rrwebSnapshot.NodeType.Element:
+        case NodeType$1.Element:
             return {
                 id,
                 type: node.RRNodeType,
@@ -1065,19 +1992,19 @@ function getDefaultSN(node, id) {
                 attributes: {},
                 childNodes: [],
             };
-        case rrwebSnapshot.NodeType.Text:
+        case NodeType$1.Text:
             return {
                 id,
                 type: node.RRNodeType,
                 textContent: node.textContent || '',
             };
-        case rrwebSnapshot.NodeType.Comment:
+        case NodeType$1.Comment:
             return {
                 id,
                 type: node.RRNodeType,
                 textContent: node.textContent || '',
             };
-        case rrwebSnapshot.NodeType.CDATA:
+        case NodeType$1.CDATA:
             return {
                 id,
                 type: node.RRNodeType,
@@ -2230,10 +3157,10 @@ class Replayer {
         this.emitter = mitt();
         this.activityIntervals = [];
         this.legacy_missingNodeRetryMap = {};
-        this.cache = rrwebSnapshot.createCache();
+        this.cache = createCache();
         this.imageMap = new Map();
         this.canvasEventMap = new Map();
-        this.mirror = rrwebSnapshot.createMirror();
+        this.mirror = createMirror$2();
         this.firstFullSnapshot = null;
         this.newDocumentQueue = [];
         this.mousePos = null;
@@ -2575,7 +3502,7 @@ class Replayer {
         this.iframe.style.pointerEvents = 'none';
     }
     resetCache() {
-        this.cache = rrwebSnapshot.createCache();
+        this.cache = createCache();
     }
     setupDom() {
         this.wrapper = document.createElement('div');
@@ -2777,7 +3704,7 @@ class Replayer {
         }
         this.legacy_missingNodeRetryMap = {};
         const collected = [];
-        rrwebSnapshot.rebuild(event.data.node, {
+        rebuild(event.data.node, {
             doc: this.iframe.contentDocument,
             afterAppend: (builtNode) => {
                 this.collectIframeAndAttachDocument(collected, builtNode);
@@ -2825,7 +3752,7 @@ class Replayer {
             const styleEl = document.createElement('style');
             documentElement.insertBefore(styleEl, head);
             for (let idx = 0; idx < injectStylesRules.length; idx++) {
-                (styleEl.sheet).insertRule(injectStylesRules[idx], idx);
+                styleEl.sheet.insertRule(injectStylesRules[idx], idx);
             }
         }
     }
@@ -2834,7 +3761,7 @@ class Replayer {
             ? this.virtualDom.mirror
             : this.mirror;
         const collected = [];
-        rrwebSnapshot.buildNodeWithSN(mutation.node, {
+        buildNodeWithSN(mutation.node, {
             doc: iframeEl.contentDocument,
             mirror: mirror,
             hackCss: true,
@@ -2842,7 +3769,7 @@ class Replayer {
             afterAppend: (builtNode) => {
                 this.collectIframeAndAttachDocument(collected, builtNode);
                 const sn = mirror.getMeta(builtNode);
-                if ((sn === null || sn === void 0 ? void 0 : sn.type) === rrwebSnapshot.NodeType.Element &&
+                if ((sn === null || sn === void 0 ? void 0 : sn.type) === NodeType$2.Element &&
                     (sn === null || sn === void 0 ? void 0 : sn.tagName.toUpperCase()) === 'HTML') {
                     const { documentElement, head } = iframeEl.contentDocument;
                     this.insertStyleRules(documentElement, head);
@@ -3210,7 +4137,7 @@ class Replayer {
                     if (!target) {
                         return this.debugNodeNotFound(d, d.id);
                     }
-                    const styleSheet = (target).sheet;
+                    const styleSheet = target.sheet;
                     (_d = d.adds) === null || _d === void 0 ? void 0 : _d.forEach(({ rule, index: nestedIndex }) => {
                         try {
                             if (Array.isArray(nestedIndex)) {
@@ -3396,7 +4323,7 @@ class Replayer {
             }
             let parent = mirror.getNode(mutation.parentId);
             if (!parent) {
-                if (mutation.node.type === rrwebSnapshot.NodeType.Document) {
+                if (mutation.node.type === NodeType$2.Document) {
                     return this.newDocumentQueue.push(mutation);
                 }
                 return queue.push(mutation);
@@ -3432,7 +4359,7 @@ class Replayer {
                 this.attachDocumentToIframe(mutation, parent);
                 return;
             }
-            const target = rrwebSnapshot.buildNodeWithSN(mutation.node, {
+            const target = buildNodeWithSN(mutation.node, {
                 doc: targetDoc,
                 mirror: mirror,
                 skipChild: true,
@@ -3448,9 +4375,9 @@ class Replayer {
             }
             const parentSn = mirror.getMeta(parent);
             if (parentSn &&
-                parentSn.type === rrwebSnapshot.NodeType.Element &&
+                parentSn.type === NodeType$2.Element &&
                 parentSn.tagName === 'textarea' &&
-                mutation.node.type === rrwebSnapshot.NodeType.Text) {
+                mutation.node.type === NodeType$2.Text) {
                 const childNodeArray = Array.isArray(parent.childNodes)
                     ? parent.childNodes
                     : Array.from(parent.childNodes);
@@ -3593,7 +4520,7 @@ class Replayer {
                 behavior: isSync ? 'auto' : 'smooth',
             });
         }
-        else if ((sn === null || sn === void 0 ? void 0 : sn.type) === rrwebSnapshot.NodeType.Document) {
+        else if ((sn === null || sn === void 0 ? void 0 : sn.type) === NodeType$2.Document) {
             target.defaultView.scrollTo({
                 top: d.y,
                 left: d.x,