@highlight-run/rrweb 1.2.0 → 2.0.1

package/lib/replay/rrweb-replay.js

@@ -0,0 +1,4211 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/*! *****************************************************************************
+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.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+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;
+}
+
+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.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 selector + ", " + 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.Document:
+            return doc.implementation.createDocument(null, '', null);
+        case NodeType.DocumentType:
+            return doc.implementation.createDocumentType(n.name || 'html', n.publicId, n.systemId);
+        case NodeType.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, PROXY_URL_1 + "?url=" + 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;
+                        }
+                    }
+                    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 (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.Text:
+            return doc.createTextNode(n.isStyle && hackCss
+                ? addHoverClass(n.textContent, cache)
+                : n.textContent);
+        case NodeType.CDATA:
+            return doc.createCDATASection(n.textContent);
+        case NodeType.Comment:
+            return doc.createComment(n.textContent);
+        default:
+            return null;
+    }
+}
+function buildNodeWithSN(n, options) {
+    var doc = options.doc, map = options.map, _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(map[n.rootId] === doc, 'Target document should has the same root id.');
+    }
+    if (n.type === NodeType.Document) {
+        doc.close();
+        doc.open();
+        if (n.compatMode === 'BackCompat' &&
+            n.childNodes &&
+            n.childNodes[0].type !== NodeType.DocumentType) {
+            if (n.childNodes[0].type === NodeType.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;
+    }
+    node.__sn = n;
+    map[n.id] = node;
+    if ((n.type === NodeType.Document || n.type === NodeType.Element) &&
+        !skipChild) {
+        for (var _i = 0, _c = n.childNodes; _i < _c.length; _i++) {
+            var childN = _c[_i];
+            var childNode = buildNodeWithSN(childN, {
+                doc: doc,
+                map: map,
+                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(idNodeMap, onVisit) {
+    function walk(node) {
+        onVisit(node);
+    }
+    for (var key in idNodeMap) {
+        if (idNodeMap[key]) {
+            walk(idNodeMap[key]);
+        }
+    }
+}
+function handleScroll(node) {
+    var n = node.__sn;
+    if (n.type !== NodeType.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;
+    var idNodeMap = {};
+    var node = buildNodeWithSN(n, {
+        doc: doc,
+        map: idNodeMap,
+        skipChild: false,
+        hackCss: hackCss,
+        afterAppend: afterAppend,
+        cache: cache
+    });
+    visit(idNodeMap, function (visitedNode) {
+        if (onVisit) {
+            onVisit(visitedNode);
+        }
+        handleScroll(visitedNode);
+    });
+    return [node, idNodeMap];
+}
+
+//      
+// An event handler can take an optional event argument
+// and should not return a value
+                                          
+                                                               
+
+// An array of all currently registered event handlers for a type
+                                            
+                                                            
+// A map of event types and their corresponding event handlers.
+                        
+                                 
+                                   
+  
+
+/** Mitt: Tiny (~200b) functional event emitter / pubsub.
+ *  @name mitt
+ *  @returns {Mitt}
+ */
+function mitt$1(all                 ) {
+	all = all || Object.create(null);
+
+	return {
+		/**
+		 * Register an event handler for the given type.
+		 *
+		 * @param  {String} type	Type of event to listen for, or `"*"` for all events
+		 * @param  {Function} handler Function to call in response to given event
+		 * @memberOf mitt
+		 */
+		on: function on(type        , handler              ) {
+			(all[type] || (all[type] = [])).push(handler);
+		},
+
+		/**
+		 * Remove an event handler for the given type.
+		 *
+		 * @param  {String} type	Type of event to unregister `handler` from, or `"*"`
+		 * @param  {Function} handler Handler function to remove
+		 * @memberOf mitt
+		 */
+		off: function off(type        , handler              ) {
+			if (all[type]) {
+				all[type].splice(all[type].indexOf(handler) >>> 0, 1);
+			}
+		},
+
+		/**
+		 * Invoke all handlers for the given type.
+		 * If present, `"*"` handlers are invoked after type-matched handlers.
+		 *
+		 * @param {String} type  The event type to invoke
+		 * @param {Any} [evt]  Any value (object is recommended and powerful), passed to each handler
+		 * @memberOf mitt
+		 */
+		emit: function emit(type        , evt     ) {
+			(all[type] || []).slice().map(function (handler) { handler(evt); });
+			(all['*'] || []).slice().map(function (handler) { handler(type, evt); });
+		}
+	};
+}
+
+var mittProxy = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    'default': mitt$1
+});
+
+function polyfill$1(w, d) {
+    if (w === void 0) { w = window; }
+    if (d === void 0) { d = document; }
+    if ('scrollBehavior' in d.documentElement.style &&
+        w.__forceSmoothScrollPolyfill__ !== true) {
+        return;
+    }
+    var Element = w.HTMLElement || w.Element;
+    var SCROLL_TIME = 468;
+    var original = {
+        scroll: w.scroll || w.scrollTo,
+        scrollBy: w.scrollBy,
+        elementScroll: Element.prototype.scroll || scrollElement,
+        scrollIntoView: Element.prototype.scrollIntoView,
+    };
+    var now = w.performance && w.performance.now
+        ? w.performance.now.bind(w.performance)
+        : Date.now;
+    function isMicrosoftBrowser(userAgent) {
+        var userAgentPatterns = ['MSIE ', 'Trident/', 'Edge/'];
+        return new RegExp(userAgentPatterns.join('|')).test(userAgent);
+    }
+    var ROUNDING_TOLERANCE = isMicrosoftBrowser(w.navigator.userAgent) ? 1 : 0;
+    function scrollElement(x, y) {
+        this.scrollLeft = x;
+        this.scrollTop = y;
+    }
+    function ease(k) {
+        return 0.5 * (1 - Math.cos(Math.PI * k));
+    }
+    function shouldBailOut(firstArg) {
+        if (firstArg === null ||
+            typeof firstArg !== 'object' ||
+            firstArg.behavior === undefined ||
+            firstArg.behavior === 'auto' ||
+            firstArg.behavior === 'instant') {
+            return true;
+        }
+        if (typeof firstArg === 'object' && firstArg.behavior === 'smooth') {
+            return false;
+        }
+        throw new TypeError('behavior member of ScrollOptions ' +
+            firstArg.behavior +
+            ' is not a valid value for enumeration ScrollBehavior.');
+    }
+    function hasScrollableSpace(el, axis) {
+        if (axis === 'Y') {
+            return el.clientHeight + ROUNDING_TOLERANCE < el.scrollHeight;
+        }
+        if (axis === 'X') {
+            return el.clientWidth + ROUNDING_TOLERANCE < el.scrollWidth;
+        }
+    }
+    function canOverflow(el, axis) {
+        var overflowValue = w.getComputedStyle(el, null)['overflow' + axis];
+        return overflowValue === 'auto' || overflowValue === 'scroll';
+    }
+    function isScrollable(el) {
+        var isScrollableY = hasScrollableSpace(el, 'Y') && canOverflow(el, 'Y');
+        var isScrollableX = hasScrollableSpace(el, 'X') && canOverflow(el, 'X');
+        return isScrollableY || isScrollableX;
+    }
+    function findScrollableParent(el) {
+        while (el !== d.body && isScrollable(el) === false) {
+            el = el.parentNode || el.host;
+        }
+        return el;
+    }
+    function step(context) {
+        var time = now();
+        var value;
+        var currentX;
+        var currentY;
+        var elapsed = (time - context.startTime) / SCROLL_TIME;
+        elapsed = elapsed > 1 ? 1 : elapsed;
+        value = ease(elapsed);
+        currentX = context.startX + (context.x - context.startX) * value;
+        currentY = context.startY + (context.y - context.startY) * value;
+        context.method.call(context.scrollable, currentX, currentY);
+        if (currentX !== context.x || currentY !== context.y) {
+            w.requestAnimationFrame(step.bind(w, context));
+        }
+    }
+    function smoothScroll(el, x, y) {
+        var scrollable;
+        var startX;
+        var startY;
+        var method;
+        var startTime = now();
+        if (el === d.body) {
+            scrollable = w;
+            startX = w.scrollX || w.pageXOffset;
+            startY = w.scrollY || w.pageYOffset;
+            method = original.scroll;
+        }
+        else {
+            scrollable = el;
+            startX = el.scrollLeft;
+            startY = el.scrollTop;
+            method = scrollElement;
+        }
+        step({
+            scrollable: scrollable,
+            method: method,
+            startTime: startTime,
+            startX: startX,
+            startY: startY,
+            x: x,
+            y: y,
+        });
+    }
+    w.scroll = w.scrollTo = function () {
+        if (arguments[0] === undefined) {
+            return;
+        }
+        if (shouldBailOut(arguments[0]) === true) {
+            original.scroll.call(w, arguments[0].left !== undefined
+                ? arguments[0].left
+                : typeof arguments[0] !== 'object'
+                    ? arguments[0]
+                    : w.scrollX || w.pageXOffset, arguments[0].top !== undefined
+                ? arguments[0].top
+                : arguments[1] !== undefined
+                    ? arguments[1]
+                    : w.scrollY || w.pageYOffset);
+            return;
+        }
+        smoothScroll.call(w, d.body, arguments[0].left !== undefined
+            ? ~~arguments[0].left
+            : w.scrollX || w.pageXOffset, arguments[0].top !== undefined
+            ? ~~arguments[0].top
+            : w.scrollY || w.pageYOffset);
+    };
+    w.scrollBy = function () {
+        if (arguments[0] === undefined) {
+            return;
+        }
+        if (shouldBailOut(arguments[0])) {
+            original.scrollBy.call(w, arguments[0].left !== undefined
+                ? arguments[0].left
+                : typeof arguments[0] !== 'object'
+                    ? arguments[0]
+                    : 0, arguments[0].top !== undefined
+                ? arguments[0].top
+                : arguments[1] !== undefined
+                    ? arguments[1]
+                    : 0);
+            return;
+        }
+        smoothScroll.call(w, d.body, ~~arguments[0].left + (w.scrollX || w.pageXOffset), ~~arguments[0].top + (w.scrollY || w.pageYOffset));
+    };
+    Element.prototype.scroll = Element.prototype.scrollTo = function () {
+        if (arguments[0] === undefined) {
+            return;
+        }
+        if (shouldBailOut(arguments[0]) === true) {
+            if (typeof arguments[0] === 'number' && arguments[1] === undefined) {
+                throw new SyntaxError('Value could not be converted');
+            }
+            original.elementScroll.call(this, arguments[0].left !== undefined
+                ? ~~arguments[0].left
+                : typeof arguments[0] !== 'object'
+                    ? ~~arguments[0]
+                    : this.scrollLeft, arguments[0].top !== undefined
+                ? ~~arguments[0].top
+                : arguments[1] !== undefined
+                    ? ~~arguments[1]
+                    : this.scrollTop);
+            return;
+        }
+        var left = arguments[0].left;
+        var top = arguments[0].top;
+        smoothScroll.call(this, this, typeof left === 'undefined' ? this.scrollLeft : ~~left, typeof top === 'undefined' ? this.scrollTop : ~~top);
+    };
+    Element.prototype.scrollBy = function () {
+        if (arguments[0] === undefined) {
+            return;
+        }
+        if (shouldBailOut(arguments[0]) === true) {
+            original.elementScroll.call(this, arguments[0].left !== undefined
+                ? ~~arguments[0].left + this.scrollLeft
+                : ~~arguments[0] + this.scrollLeft, arguments[0].top !== undefined
+                ? ~~arguments[0].top + this.scrollTop
+                : ~~arguments[1] + this.scrollTop);
+            return;
+        }
+        this.scroll({
+            left: ~~arguments[0].left + this.scrollLeft,
+            top: ~~arguments[0].top + this.scrollTop,
+            behavior: arguments[0].behavior,
+        });
+    };
+    Element.prototype.scrollIntoView = function () {
+        if (shouldBailOut(arguments[0]) === true) {
+            original.scrollIntoView.call(this, arguments[0] === undefined ? true : arguments[0]);
+            return;
+        }
+        var scrollableParent = findScrollableParent(this);
+        var parentRects = scrollableParent.getBoundingClientRect();
+        var clientRects = this.getBoundingClientRect();
+        if (scrollableParent !== d.body) {
+            smoothScroll.call(this, scrollableParent, scrollableParent.scrollLeft + clientRects.left - parentRects.left, scrollableParent.scrollTop + clientRects.top - parentRects.top);
+            if (w.getComputedStyle(scrollableParent).position !== 'fixed') {
+                w.scrollBy({
+                    left: parentRects.left,
+                    top: parentRects.top,
+                    behavior: 'smooth',
+                });
+            }
+        }
+        else {
+            w.scrollBy({
+                left: clientRects.left,
+                top: clientRects.top,
+                behavior: 'smooth',
+            });
+        }
+    };
+}
+
+var EventType;
+(function (EventType) {
+    EventType[EventType["DomContentLoaded"] = 0] = "DomContentLoaded";
+    EventType[EventType["Load"] = 1] = "Load";
+    EventType[EventType["FullSnapshot"] = 2] = "FullSnapshot";
+    EventType[EventType["IncrementalSnapshot"] = 3] = "IncrementalSnapshot";
+    EventType[EventType["Meta"] = 4] = "Meta";
+    EventType[EventType["Custom"] = 5] = "Custom";
+    EventType[EventType["Plugin"] = 6] = "Plugin";
+})(EventType || (EventType = {}));
+var IncrementalSource;
+(function (IncrementalSource) {
+    IncrementalSource[IncrementalSource["Mutation"] = 0] = "Mutation";
+    IncrementalSource[IncrementalSource["MouseMove"] = 1] = "MouseMove";
+    IncrementalSource[IncrementalSource["MouseInteraction"] = 2] = "MouseInteraction";
+    IncrementalSource[IncrementalSource["Scroll"] = 3] = "Scroll";
+    IncrementalSource[IncrementalSource["ViewportResize"] = 4] = "ViewportResize";
+    IncrementalSource[IncrementalSource["Input"] = 5] = "Input";
+    IncrementalSource[IncrementalSource["TouchMove"] = 6] = "TouchMove";
+    IncrementalSource[IncrementalSource["MediaInteraction"] = 7] = "MediaInteraction";
+    IncrementalSource[IncrementalSource["StyleSheetRule"] = 8] = "StyleSheetRule";
+    IncrementalSource[IncrementalSource["CanvasMutation"] = 9] = "CanvasMutation";
+    IncrementalSource[IncrementalSource["Font"] = 10] = "Font";
+    IncrementalSource[IncrementalSource["Log"] = 11] = "Log";
+    IncrementalSource[IncrementalSource["Drag"] = 12] = "Drag";
+    IncrementalSource[IncrementalSource["StyleDeclaration"] = 13] = "StyleDeclaration";
+})(IncrementalSource || (IncrementalSource = {}));
+var MouseInteractions;
+(function (MouseInteractions) {
+    MouseInteractions[MouseInteractions["MouseUp"] = 0] = "MouseUp";
+    MouseInteractions[MouseInteractions["MouseDown"] = 1] = "MouseDown";
+    MouseInteractions[MouseInteractions["Click"] = 2] = "Click";
+    MouseInteractions[MouseInteractions["ContextMenu"] = 3] = "ContextMenu";
+    MouseInteractions[MouseInteractions["DblClick"] = 4] = "DblClick";
+    MouseInteractions[MouseInteractions["Focus"] = 5] = "Focus";
+    MouseInteractions[MouseInteractions["Blur"] = 6] = "Blur";
+    MouseInteractions[MouseInteractions["TouchStart"] = 7] = "TouchStart";
+    MouseInteractions[MouseInteractions["TouchMove_Departed"] = 8] = "TouchMove_Departed";
+    MouseInteractions[MouseInteractions["TouchEnd"] = 9] = "TouchEnd";
+    MouseInteractions[MouseInteractions["TouchCancel"] = 10] = "TouchCancel";
+})(MouseInteractions || (MouseInteractions = {}));
+var CanvasContext;
+(function (CanvasContext) {
+    CanvasContext[CanvasContext["2D"] = 0] = "2D";
+    CanvasContext[CanvasContext["WebGL"] = 1] = "WebGL";
+    CanvasContext[CanvasContext["WebGL2"] = 2] = "WebGL2";
+})(CanvasContext || (CanvasContext = {}));
+var MediaInteractions;
+(function (MediaInteractions) {
+    MediaInteractions[MediaInteractions["Play"] = 0] = "Play";
+    MediaInteractions[MediaInteractions["Pause"] = 1] = "Pause";
+    MediaInteractions[MediaInteractions["Seeked"] = 2] = "Seeked";
+    MediaInteractions[MediaInteractions["VolumeChange"] = 3] = "VolumeChange";
+})(MediaInteractions || (MediaInteractions = {}));
+var ReplayerEvents;
+(function (ReplayerEvents) {
+    ReplayerEvents["Start"] = "start";
+    ReplayerEvents["Pause"] = "pause";
+    ReplayerEvents["Resume"] = "resume";
+    ReplayerEvents["Resize"] = "resize";
+    ReplayerEvents["Finish"] = "finish";
+    ReplayerEvents["FullsnapshotRebuilded"] = "fullsnapshot-rebuilded";
+    ReplayerEvents["LoadStylesheetStart"] = "load-stylesheet-start";
+    ReplayerEvents["LoadStylesheetEnd"] = "load-stylesheet-end";
+    ReplayerEvents["SkipStart"] = "skip-start";
+    ReplayerEvents["SkipEnd"] = "skip-end";
+    ReplayerEvents["MouseInteraction"] = "mouse-interaction";
+    ReplayerEvents["EventCast"] = "event-cast";
+    ReplayerEvents["CustomEvent"] = "custom-event";
+    ReplayerEvents["Flush"] = "flush";
+    ReplayerEvents["StateChange"] = "state-change";
+    ReplayerEvents["PlayBack"] = "play-back";
+})(ReplayerEvents || (ReplayerEvents = {}));
+
+var Timer = (function () {
+    function Timer(actions, speed) {
+        if (actions === void 0) { actions = []; }
+        this.timeOffset = 0;
+        this.raf = null;
+        this.actions = actions;
+        this.speed = speed;
+    }
+    Timer.prototype.addAction = function (action) {
+        var index = this.findActionIndex(action);
+        this.actions.splice(index, 0, action);
+    };
+    Timer.prototype.addActions = function (actions) {
+        this.actions = this.actions.concat(actions);
+    };
+    Timer.prototype.replaceActions = function (actions) {
+        var _a;
+        this.actions.length = 0;
+        (_a = this.actions).splice.apply(_a, __spreadArray([0, 0], __read(actions), false));
+    };
+    Timer.prototype.start = function () {
+        this.timeOffset = 0;
+        var lastTimestamp = performance.now();
+        var actions = this.actions;
+        var self = this;
+        function check() {
+            var time = performance.now();
+            self.timeOffset += (time - lastTimestamp) * self.speed;
+            lastTimestamp = time;
+            while (actions.length) {
+                var action = actions[0];
+                if (self.timeOffset >= action.delay) {
+                    actions.shift();
+                    action.doAction();
+                }
+                else {
+                    break;
+                }
+            }
+            if (actions.length > 0 || self.liveMode) {
+                self.raf = requestAnimationFrame(check);
+            }
+        }
+        this.raf = requestAnimationFrame(check);
+    };
+    Timer.prototype.clear = function () {
+        if (this.raf) {
+            cancelAnimationFrame(this.raf);
+            this.raf = null;
+        }
+        this.actions.length = 0;
+    };
+    Timer.prototype.setSpeed = function (speed) {
+        this.speed = speed;
+    };
+    Timer.prototype.toggleLiveMode = function (mode) {
+        this.liveMode = mode;
+    };
+    Timer.prototype.isActive = function () {
+        return this.raf !== null;
+    };
+    Timer.prototype.findActionIndex = function (action) {
+        var start = 0;
+        var end = this.actions.length - 1;
+        while (start <= end) {
+            var mid = Math.floor((start + end) / 2);
+            if (this.actions[mid].delay < action.delay) {
+                start = mid + 1;
+            }
+            else if (this.actions[mid].delay > action.delay) {
+                end = mid - 1;
+            }
+            else {
+                return mid + 1;
+            }
+        }
+        return start;
+    };
+    return Timer;
+}());
+function addDelay(event, baselineTime) {
+    if (event.type === EventType.IncrementalSnapshot &&
+        event.data.source === IncrementalSource.MouseMove) {
+        var firstOffset = event.data.positions[0].timeOffset;
+        var firstTimestamp = event.timestamp + firstOffset;
+        event.delay = firstTimestamp - baselineTime;
+        return firstTimestamp - baselineTime;
+    }
+    event.delay = event.timestamp - baselineTime;
+    return event.delay;
+}
+
+/*! *****************************************************************************
+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 t(t,n){var e="function"==typeof Symbol&&t[Symbol.iterator];if(!e)return t;var r,o,i=e.call(t),a=[];try{for(;(void 0===n||n-- >0)&&!(r=i.next()).done;)a.push(r.value);}catch(t){o={error:t};}finally{try{r&&!r.done&&(e=i.return)&&e.call(i);}finally{if(o)throw o.error}}return a}var n;!function(t){t[t.NotStarted=0]="NotStarted",t[t.Running=1]="Running",t[t.Stopped=2]="Stopped";}(n||(n={}));var e={type:"xstate.init"};function r(t){return void 0===t?[]:[].concat(t)}function o(t){return {type:"xstate.assign",assignment:t}}function i$1(t,n){return "string"==typeof(t="string"==typeof t&&n&&n[t]?n[t]:t)?{type:t}:"function"==typeof t?{type:t.name,exec:t}:t}function a(t){return function(n){return t===n}}function u(t){return "string"==typeof t?{type:t}:t}function c(t,n){return {value:t,context:n,actions:[],changed:!1,matches:a(t)}}function f(t,n,e){var r=n,o=!1;return [t.filter((function(t){if("xstate.assign"===t.type){o=!0;var n=Object.assign({},r);return "function"==typeof t.assignment?n=t.assignment(r,e):Object.keys(t.assignment).forEach((function(o){n[o]="function"==typeof t.assignment[o]?t.assignment[o](r,e):t.assignment[o];})),r=n,!1}return !0})),r,o]}function s(n,o){void 0===o&&(o={});var s=t(f(r(n.states[n.initial].entry).map((function(t){return i$1(t,o.actions)})),n.context,e),2),l=s[0],v=s[1],y={config:n,_options:o,initialState:{value:n.initial,actions:l,context:v,matches:a(n.initial)},transition:function(e,o){var s,l,v="string"==typeof e?{value:e,context:n.context}:e,p=v.value,g=v.context,d=u(o),x=n.states[p];if(x.on){var m=r(x.on[d.type]);try{for(var h=function(t){var n="function"==typeof Symbol&&Symbol.iterator,e=n&&t[n],r=0;if(e)return e.call(t);if(t&&"number"==typeof t.length)return {next:function(){return t&&r>=t.length&&(t=void 0),{value:t&&t[r++],done:!t}}};throw new TypeError(n?"Object is not iterable.":"Symbol.iterator is not defined.")}(m),b=h.next();!b.done;b=h.next()){var S=b.value;if(void 0===S)return c(p,g);var w="string"==typeof S?{target:S}:S,j=w.target,E=w.actions,R=void 0===E?[]:E,N=w.cond,O=void 0===N?function(){return !0}:N,_=void 0===j,k=null!=j?j:p,T=n.states[k];if(O(g,d)){var q=t(f((_?r(R):[].concat(x.exit,R,T.entry).filter((function(t){return t}))).map((function(t){return i$1(t,y._options.actions)})),g,d),3),z=q[0],A=q[1],B=q[2],C=null!=j?j:p;return {value:C,context:A,actions:z,changed:j!==p||z.length>0||B,matches:a(C)}}}}catch(t){s={error:t};}finally{try{b&&!b.done&&(l=h.return)&&l.call(h);}finally{if(s)throw s.error}}}return c(p,g)}};return y}var l=function(t,n){return t.actions.forEach((function(e){var r=e.exec;return r&&r(t.context,n)}))};function v(t){var r=t.initialState,o=n.NotStarted,i=new Set,c={_machine:t,send:function(e){o===n.Running&&(r=t.transition(r,e),l(r,u(e)),i.forEach((function(t){return t(r)})));},subscribe:function(t){return i.add(t),t(r),{unsubscribe:function(){return i.delete(t)}}},start:function(i){if(i){var u="object"==typeof i?i:{context:t.config.context,value:i};r={value:u.value,actions:[],context:u.context,matches:a(u.value)};}return o=n.Running,l(r,e),c},stop:function(){return o=n.Stopped,i.clear(),c},get state(){return r},get status(){return o}};return c}
+
+function discardPriorSnapshots(events, baselineTime) {
+    for (var idx = events.length - 1; idx >= 0; idx--) {
+        var event_1 = events[idx];
+        if (event_1.type === EventType.Meta) {
+            if (event_1.timestamp <= baselineTime) {
+                return events.slice(idx);
+            }
+        }
+    }
+    return events;
+}
+function createPlayerService(context, _a) {
+    var getCastFn = _a.getCastFn, applyEventsSynchronously = _a.applyEventsSynchronously, emitter = _a.emitter;
+    var playerMachine = s({
+        id: 'player',
+        context: context,
+        initial: 'paused',
+        states: {
+            playing: {
+                on: {
+                    PAUSE: {
+                        target: 'paused',
+                        actions: ['pause'],
+                    },
+                    CAST_EVENT: {
+                        target: 'playing',
+                        actions: 'castEvent',
+                    },
+                    END: {
+                        target: 'paused',
+                        actions: ['resetLastPlayedEvent', 'pause'],
+                    },
+                    ADD_EVENT: {
+                        target: 'playing',
+                        actions: ['addEvent'],
+                    },
+                    REPLACE_EVENTS: {
+                        target: 'playing',
+                        actions: ['replaceEvents'],
+                    },
+                },
+            },
+            paused: {
+                on: {
+                    PLAY: {
+                        target: 'playing',
+                        actions: ['recordTimeOffset', 'play'],
+                    },
+                    CAST_EVENT: {
+                        target: 'paused',
+                        actions: 'castEvent',
+                    },
+                    TO_LIVE: {
+                        target: 'live',
+                        actions: ['startLive'],
+                    },
+                    ADD_EVENT: {
+                        target: 'paused',
+                        actions: ['addEvent'],
+                    },
+                    REPLACE_EVENTS: {
+                        target: 'paused',
+                        actions: ['replaceEvents'],
+                    },
+                },
+            },
+            live: {
+                on: {
+                    ADD_EVENT: {
+                        target: 'live',
+                        actions: ['addEvent'],
+                    },
+                    CAST_EVENT: {
+                        target: 'live',
+                        actions: ['castEvent'],
+                    },
+                },
+            },
+        },
+    }, {
+        actions: {
+            castEvent: o({
+                lastPlayedEvent: function (ctx, event) {
+                    if (event.type === 'CAST_EVENT') {
+                        return event.payload.event;
+                    }
+                    return ctx.lastPlayedEvent;
+                },
+            }),
+            recordTimeOffset: o(function (ctx, event) {
+                var timeOffset = ctx.timeOffset;
+                if ('payload' in event && 'timeOffset' in event.payload) {
+                    timeOffset = event.payload.timeOffset;
+                }
+                return __assign(__assign({}, ctx), { timeOffset: timeOffset, baselineTime: ctx.events[0].timestamp + timeOffset });
+            }),
+            play: function (ctx) {
+                var e_1, _a, e_2, _b;
+                var _c;
+                var timer = ctx.timer, events = ctx.events, baselineTime = ctx.baselineTime, lastPlayedEvent = ctx.lastPlayedEvent;
+                timer.clear();
+                try {
+                    for (var events_1 = __values(events), events_1_1 = events_1.next(); !events_1_1.done; events_1_1 = events_1.next()) {
+                        var event_2 = events_1_1.value;
+                        addDelay(event_2, baselineTime);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (events_1_1 && !events_1_1.done && (_a = events_1.return)) _a.call(events_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                var neededEvents = discardPriorSnapshots(events, baselineTime);
+                var lastPlayedTimestamp = lastPlayedEvent === null || lastPlayedEvent === void 0 ? void 0 : lastPlayedEvent.timestamp;
+                if ((lastPlayedEvent === null || lastPlayedEvent === void 0 ? void 0 : lastPlayedEvent.type) === EventType.IncrementalSnapshot &&
+                    lastPlayedEvent.data.source === IncrementalSource.MouseMove) {
+                    lastPlayedTimestamp =
+                        lastPlayedEvent.timestamp +
+                            ((_c = lastPlayedEvent.data.positions[0]) === null || _c === void 0 ? void 0 : _c.timeOffset);
+                }
+                if (baselineTime < (lastPlayedTimestamp || 0)) {
+                    emitter.emit(ReplayerEvents.PlayBack);
+                }
+                var syncEvents = new Array();
+                var actions = new Array();
+                var _loop_1 = function (event_3) {
+                    if (lastPlayedTimestamp &&
+                        lastPlayedTimestamp < baselineTime &&
+                        (event_3.timestamp <= lastPlayedTimestamp ||
+                            event_3 === lastPlayedEvent)) {
+                        return "continue";
+                    }
+                    if (event_3.timestamp < baselineTime) {
+                        syncEvents.push(event_3);
+                    }
+                    else {
+                        var castFn_1 = getCastFn(event_3, false);
+                        actions.push({
+                            doAction: function () {
+                                castFn_1();
+                            },
+                            delay: event_3.delay,
+                        });
+                    }
+                };
+                try {
+                    for (var neededEvents_1 = __values(neededEvents), neededEvents_1_1 = neededEvents_1.next(); !neededEvents_1_1.done; neededEvents_1_1 = neededEvents_1.next()) {
+                        var event_3 = neededEvents_1_1.value;
+                        _loop_1(event_3);
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (neededEvents_1_1 && !neededEvents_1_1.done && (_b = neededEvents_1.return)) _b.call(neededEvents_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                applyEventsSynchronously(syncEvents);
+                emitter.emit(ReplayerEvents.Flush);
+                timer.addActions(actions);
+                timer.start();
+            },
+            pause: function (ctx) {
+                ctx.timer.clear();
+            },
+            resetLastPlayedEvent: o(function (ctx) {
+                return __assign(__assign({}, ctx), { lastPlayedEvent: null });
+            }),
+            startLive: o({
+                baselineTime: function (ctx, event) {
+                    ctx.timer.toggleLiveMode(true);
+                    ctx.timer.start();
+                    if (event.type === 'TO_LIVE' && event.payload.baselineTime) {
+                        return event.payload.baselineTime;
+                    }
+                    return Date.now();
+                },
+            }),
+            replaceEvents: o(function (ctx, machineEvent) {
+                var e_3, _a;
+                var curEvents = ctx.events, timer = ctx.timer, baselineTime = ctx.baselineTime;
+                if (machineEvent.type === 'REPLACE_EVENTS') {
+                    var newEvents = machineEvent.payload.events;
+                    curEvents.length = 0;
+                    var actions = [];
+                    var _loop_2 = function (event_4) {
+                        addDelay(event_4, baselineTime);
+                        curEvents.push(event_4);
+                        if (event_4.timestamp >= timer.timeOffset + baselineTime) {
+                            var castFn_2 = getCastFn(event_4, false);
+                            actions.push({
+                                doAction: function () {
+                                    castFn_2();
+                                },
+                                delay: event_4.delay,
+                            });
+                        }
+                    };
+                    try {
+                        for (var newEvents_1 = __values(newEvents), newEvents_1_1 = newEvents_1.next(); !newEvents_1_1.done; newEvents_1_1 = newEvents_1.next()) {
+                            var event_4 = newEvents_1_1.value;
+                            _loop_2(event_4);
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (newEvents_1_1 && !newEvents_1_1.done && (_a = newEvents_1.return)) _a.call(newEvents_1);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                    if (timer.isActive()) {
+                        timer.replaceActions(actions);
+                    }
+                }
+                return __assign(__assign({}, ctx), { events: curEvents });
+            }),
+            addEvent: o(function (ctx, machineEvent) {
+                var baselineTime = ctx.baselineTime, timer = ctx.timer, events = ctx.events;
+                if (machineEvent.type === 'ADD_EVENT') {
+                    var event_5 = machineEvent.payload.event;
+                    addDelay(event_5, baselineTime);
+                    var end = events.length - 1;
+                    if (!events[end] || events[end].timestamp <= event_5.timestamp) {
+                        events.push(event_5);
+                    }
+                    else {
+                        var insertionIndex = -1;
+                        var start = 0;
+                        while (start <= end) {
+                            var mid = Math.floor((start + end) / 2);
+                            if (events[mid].timestamp <= event_5.timestamp) {
+                                start = mid + 1;
+                            }
+                            else {
+                                end = mid - 1;
+                            }
+                        }
+                        if (insertionIndex === -1) {
+                            insertionIndex = start;
+                        }
+                        events.splice(insertionIndex, 0, event_5);
+                    }
+                    var isSync = event_5.timestamp < baselineTime;
+                    var castFn_3 = getCastFn(event_5, isSync);
+                    if (isSync) {
+                        castFn_3();
+                    }
+                    else if (timer.isActive()) {
+                        timer.addAction({
+                            doAction: function () {
+                                castFn_3();
+                            },
+                            delay: event_5.delay,
+                        });
+                    }
+                }
+                return __assign(__assign({}, ctx), { events: events });
+            }),
+        },
+    });
+    return v(playerMachine);
+}
+function createSpeedService(context) {
+    var speedMachine = s({
+        id: 'speed',
+        context: context,
+        initial: 'normal',
+        states: {
+            normal: {
+                on: {
+                    FAST_FORWARD: {
+                        target: 'skipping',
+                        actions: ['recordSpeed', 'setSpeed'],
+                    },
+                    SET_SPEED: {
+                        target: 'normal',
+                        actions: ['setSpeed'],
+                    },
+                },
+            },
+            skipping: {
+                on: {
+                    BACK_TO_NORMAL: {
+                        target: 'normal',
+                        actions: ['restoreSpeed'],
+                    },
+                    SET_SPEED: {
+                        target: 'normal',
+                        actions: ['setSpeed'],
+                    },
+                },
+            },
+        },
+    }, {
+        actions: {
+            setSpeed: function (ctx, event) {
+                if ('payload' in event) {
+                    ctx.timer.setSpeed(event.payload.speed);
+                }
+            },
+            recordSpeed: o({
+                normalSpeed: function (ctx) { return ctx.timer.speed; },
+            }),
+            restoreSpeed: function (ctx) {
+                ctx.timer.setSpeed(ctx.normalSpeed);
+            },
+        },
+    });
+    return v(speedMachine);
+}
+
+function createMirror() {
+    return {
+        map: {},
+        getId: function (n) {
+            if (!n || !n.__sn) {
+                return -1;
+            }
+            return n.__sn.id;
+        },
+        getNode: function (id) {
+            return this.map[id] || null;
+        },
+        removeNodeFromMap: function (n) {
+            var _this = this;
+            var id = n.__sn && n.__sn.id;
+            delete this.map[id];
+            if (n.childNodes) {
+                n.childNodes.forEach(function (child) {
+                    return _this.removeNodeFromMap(child);
+                });
+            }
+        },
+        has: function (id) {
+            return this.map.hasOwnProperty(id);
+        },
+        reset: function () {
+            this.map = {};
+        },
+    };
+}
+var 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.';
+var _mirror = {
+    map: {},
+    getId: function () {
+        console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+        return -1;
+    },
+    getNode: function () {
+        console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+        return null;
+    },
+    removeNodeFromMap: function () {
+        console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+    },
+    has: function () {
+        console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+        return false;
+    },
+    reset: function () {
+        console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+    },
+};
+if (typeof window !== 'undefined' && window.Proxy && window.Reflect) {
+    _mirror = new Proxy(_mirror, {
+        get: function (target, prop, receiver) {
+            if (prop === 'map') {
+                console.error(DEPARTED_MIRROR_ACCESS_WARNING);
+            }
+            return Reflect.get(target, prop, receiver);
+        },
+    });
+}
+function polyfill(win) {
+    if (win === void 0) { 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 = function contains(node) {
+            if (!(0 in arguments)) {
+                throw new TypeError('1 argument is required');
+            }
+            do {
+                if (this === node) {
+                    return true;
+                }
+            } while ((node = node && node.parentNode));
+            return false;
+        };
+    }
+}
+var TreeIndex = (function () {
+    function TreeIndex() {
+        this.reset();
+    }
+    TreeIndex.prototype.add = function (mutation) {
+        var parentTreeNode = this.indexes.get(mutation.parentId);
+        var treeNode = {
+            id: mutation.node.id,
+            mutation: mutation,
+            children: [],
+            texts: [],
+            attributes: [],
+        };
+        if (!parentTreeNode) {
+            this.tree[treeNode.id] = treeNode;
+        }
+        else {
+            treeNode.parent = parentTreeNode;
+            parentTreeNode.children[treeNode.id] = treeNode;
+        }
+        this.indexes.set(treeNode.id, treeNode);
+    };
+    TreeIndex.prototype.remove = function (mutation, mirror) {
+        var _this = this;
+        var parentTreeNode = this.indexes.get(mutation.parentId);
+        var treeNode = this.indexes.get(mutation.id);
+        var deepRemoveFromMirror = function (id) {
+            _this.removeIdSet.add(id);
+            var node = mirror.getNode(id);
+            node === null || node === void 0 ? void 0 : node.childNodes.forEach(function (childNode) {
+                if ('__sn' in childNode) {
+                    deepRemoveFromMirror(childNode.__sn.id);
+                }
+            });
+        };
+        var deepRemoveFromTreeIndex = function (node) {
+            _this.removeIdSet.add(node.id);
+            Object.values(node.children).forEach(function (n) { return deepRemoveFromTreeIndex(n); });
+            var _treeNode = _this.indexes.get(node.id);
+            if (_treeNode) {
+                var _parentTreeNode = _treeNode.parent;
+                if (_parentTreeNode) {
+                    delete _treeNode.parent;
+                    delete _parentTreeNode.children[_treeNode.id];
+                    _this.indexes.delete(mutation.id);
+                }
+            }
+        };
+        if (!treeNode) {
+            this.removeNodeMutations.push(mutation);
+            deepRemoveFromMirror(mutation.id);
+        }
+        else if (!parentTreeNode) {
+            delete this.tree[treeNode.id];
+            this.indexes.delete(treeNode.id);
+            deepRemoveFromTreeIndex(treeNode);
+        }
+        else {
+            delete treeNode.parent;
+            delete parentTreeNode.children[treeNode.id];
+            this.indexes.delete(mutation.id);
+            deepRemoveFromTreeIndex(treeNode);
+        }
+    };
+    TreeIndex.prototype.text = function (mutation) {
+        var treeNode = this.indexes.get(mutation.id);
+        if (treeNode) {
+            treeNode.texts.push(mutation);
+        }
+        else {
+            this.textMutations.push(mutation);
+        }
+    };
+    TreeIndex.prototype.attribute = function (mutation) {
+        var treeNode = this.indexes.get(mutation.id);
+        if (treeNode) {
+            treeNode.attributes.push(mutation);
+        }
+        else {
+            this.attributeMutations.push(mutation);
+        }
+    };
+    TreeIndex.prototype.scroll = function (d) {
+        this.scrollMap.set(d.id, d);
+    };
+    TreeIndex.prototype.input = function (d) {
+        this.inputMap.set(d.id, d);
+    };
+    TreeIndex.prototype.flush = function () {
+        var e_1, _a, e_2, _b;
+        var _this = this;
+        var _c = this, tree = _c.tree, removeNodeMutations = _c.removeNodeMutations, textMutations = _c.textMutations, attributeMutations = _c.attributeMutations;
+        var batchMutationData = {
+            source: IncrementalSource.Mutation,
+            removes: removeNodeMutations,
+            texts: textMutations,
+            attributes: attributeMutations,
+            adds: [],
+        };
+        var walk = function (treeNode, removed) {
+            if (removed) {
+                _this.removeIdSet.add(treeNode.id);
+            }
+            batchMutationData.texts = batchMutationData.texts
+                .concat(removed ? [] : treeNode.texts)
+                .filter(function (m) { return !_this.removeIdSet.has(m.id); });
+            batchMutationData.attributes = batchMutationData.attributes
+                .concat(removed ? [] : treeNode.attributes)
+                .filter(function (m) { return !_this.removeIdSet.has(m.id); });
+            if (!_this.removeIdSet.has(treeNode.id) &&
+                !_this.removeIdSet.has(treeNode.mutation.parentId) &&
+                !removed) {
+                batchMutationData.adds.push(treeNode.mutation);
+                if (treeNode.children) {
+                    Object.values(treeNode.children).forEach(function (n) { return walk(n, false); });
+                }
+            }
+            else {
+                Object.values(treeNode.children).forEach(function (n) { return walk(n, true); });
+            }
+        };
+        Object.values(tree).forEach(function (n) { return walk(n, false); });
+        try {
+            for (var _d = __values(this.scrollMap.keys()), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var id = _e.value;
+                if (this.removeIdSet.has(id)) {
+                    this.scrollMap.delete(id);
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        try {
+            for (var _f = __values(this.inputMap.keys()), _g = _f.next(); !_g.done; _g = _f.next()) {
+                var id = _g.value;
+                if (this.removeIdSet.has(id)) {
+                    this.inputMap.delete(id);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        var scrollMap = new Map(this.scrollMap);
+        var inputMap = new Map(this.inputMap);
+        this.reset();
+        return {
+            mutationData: batchMutationData,
+            scrollMap: scrollMap,
+            inputMap: inputMap,
+        };
+    };
+    TreeIndex.prototype.reset = function () {
+        this.tree = [];
+        this.indexes = new Map();
+        this.removeNodeMutations = [];
+        this.textMutations = [];
+        this.attributeMutations = [];
+        this.removeIdSet = new Set();
+        this.scrollMap = new Map();
+        this.inputMap = new Map();
+    };
+    TreeIndex.prototype.idRemoved = function (id) {
+        return this.removeIdSet.has(id);
+    };
+    return TreeIndex;
+}());
+function queueToResolveTrees(queue) {
+    var e_3, _a;
+    var queueNodeMap = {};
+    var putIntoMap = function (m, parent) {
+        var nodeInTree = {
+            value: m,
+            parent: parent,
+            children: [],
+        };
+        queueNodeMap[m.node.id] = nodeInTree;
+        return nodeInTree;
+    };
+    var queueNodeTrees = [];
+    try {
+        for (var queue_1 = __values(queue), queue_1_1 = queue_1.next(); !queue_1_1.done; queue_1_1 = queue_1.next()) {
+            var mutation = queue_1_1.value;
+            var nextId = mutation.nextId, parentId = mutation.parentId;
+            if (nextId && nextId in queueNodeMap) {
+                var nextInTree = queueNodeMap[nextId];
+                if (nextInTree.parent) {
+                    var idx = nextInTree.parent.children.indexOf(nextInTree);
+                    nextInTree.parent.children.splice(idx, 0, putIntoMap(mutation, nextInTree.parent));
+                }
+                else {
+                    var idx = queueNodeTrees.indexOf(nextInTree);
+                    queueNodeTrees.splice(idx, 0, putIntoMap(mutation, null));
+                }
+                continue;
+            }
+            if (parentId in queueNodeMap) {
+                var parentInTree = queueNodeMap[parentId];
+                parentInTree.children.push(putIntoMap(mutation, parentInTree));
+                continue;
+            }
+            queueNodeTrees.push(putIntoMap(mutation, null));
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (queue_1_1 && !queue_1_1.done && (_a = queue_1.return)) _a.call(queue_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return queueNodeTrees;
+}
+function iterateResolveTree(tree, cb) {
+    cb(tree.value);
+    for (var i = tree.children.length - 1; i >= 0; i--) {
+        iterateResolveTree(tree.children[i], cb);
+    }
+}
+function isIframeINode(node) {
+    if ('__sn' in node) {
+        return (node.__sn.type === NodeType.Element && node.__sn.tagName === 'iframe');
+    }
+    return false;
+}
+function getBaseDimension(node, rootIframe) {
+    var _a, _b;
+    var frameElement = (_b = (_a = node.ownerDocument) === null || _a === void 0 ? void 0 : _a.defaultView) === null || _b === void 0 ? void 0 : _b.frameElement;
+    if (!frameElement || frameElement === rootIframe) {
+        return {
+            x: 0,
+            y: 0,
+            relativeScale: 1,
+            absoluteScale: 1,
+        };
+    }
+    var frameDimension = frameElement.getBoundingClientRect();
+    var frameBaseDimension = getBaseDimension(frameElement, rootIframe);
+    var relativeScale = frameDimension.height / frameElement.clientHeight;
+    return {
+        x: frameDimension.x * frameBaseDimension.relativeScale +
+            frameBaseDimension.x,
+        y: frameDimension.y * frameBaseDimension.relativeScale +
+            frameBaseDimension.y,
+        relativeScale: relativeScale,
+        absoluteScale: frameBaseDimension.absoluteScale * relativeScale,
+    };
+}
+function hasShadowRoot(n) {
+    return Boolean(n === null || n === void 0 ? void 0 : n.shadowRoot);
+}
+
+var rules = function (blockClass) { return [
+    ".".concat(blockClass, " { background: currentColor }"),
+    'noscript { display: none !important; }',
+    ".".concat(blockClass, " { background: currentColor; border-radius: 5px; }"),
+    ".".concat(blockClass, ":hover::after {content: 'Redacted'; color: white; background: black; text-align: center; width: 100%; display: block;}"),
+]; };
+
+var StyleRuleType;
+(function (StyleRuleType) {
+    StyleRuleType[StyleRuleType["Insert"] = 0] = "Insert";
+    StyleRuleType[StyleRuleType["Remove"] = 1] = "Remove";
+    StyleRuleType[StyleRuleType["Snapshot"] = 2] = "Snapshot";
+    StyleRuleType[StyleRuleType["SetProperty"] = 3] = "SetProperty";
+    StyleRuleType[StyleRuleType["RemoveProperty"] = 4] = "RemoveProperty";
+})(StyleRuleType || (StyleRuleType = {}));
+function getNestedRule(rules, position) {
+    var rule = rules[position[0]];
+    if (position.length === 1) {
+        return rule;
+    }
+    else {
+        return getNestedRule(rule.cssRules[position[1]]
+            .cssRules, position.slice(2));
+    }
+}
+function getPositionsAndIndex(nestedIndex) {
+    var positions = __spreadArray([], __read(nestedIndex), false);
+    var index = positions.pop();
+    return { positions: positions, index: index };
+}
+function applyVirtualStyleRulesToNode(storedRules, styleNode) {
+    var sheet = styleNode.sheet;
+    if (!sheet) {
+        return;
+    }
+    storedRules.forEach(function (rule) {
+        if (rule.type === StyleRuleType.Insert) {
+            try {
+                if (Array.isArray(rule.index)) {
+                    var _a = getPositionsAndIndex(rule.index), positions = _a.positions, index = _a.index;
+                    var nestedRule = getNestedRule(sheet.cssRules, positions);
+                    nestedRule.insertRule(rule.cssText, index);
+                }
+                else {
+                    sheet.insertRule(rule.cssText, rule.index);
+                }
+            }
+            catch (e) {
+            }
+        }
+        else if (rule.type === StyleRuleType.Remove) {
+            try {
+                if (Array.isArray(rule.index)) {
+                    var _b = getPositionsAndIndex(rule.index), positions = _b.positions, index = _b.index;
+                    var nestedRule = getNestedRule(sheet.cssRules, positions);
+                    nestedRule.deleteRule(index || 0);
+                }
+                else {
+                    sheet.deleteRule(rule.index);
+                }
+            }
+            catch (e) {
+            }
+        }
+        else if (rule.type === StyleRuleType.Snapshot) {
+            restoreSnapshotOfStyleRulesToNode(rule.cssTexts, styleNode);
+        }
+        else if (rule.type === StyleRuleType.SetProperty) {
+            var nativeRule = getNestedRule(sheet.cssRules, rule.index);
+            nativeRule.style.setProperty(rule.property, rule.value, rule.priority);
+        }
+        else if (rule.type === StyleRuleType.RemoveProperty) {
+            var nativeRule = getNestedRule(sheet.cssRules, rule.index);
+            nativeRule.style.removeProperty(rule.property);
+        }
+    });
+}
+function restoreSnapshotOfStyleRulesToNode(cssTexts, styleNode) {
+    var _a;
+    try {
+        var existingRules = Array.from(((_a = styleNode.sheet) === null || _a === void 0 ? void 0 : _a.cssRules) || []).map(function (rule) { return rule.cssText; });
+        var existingRulesReversed = Object.entries(existingRules).reverse();
+        var lastMatch_1 = existingRules.length;
+        existingRulesReversed.forEach(function (_a) {
+            var _b;
+            var _c = __read(_a, 2), index = _c[0], rule = _c[1];
+            var indexOf = cssTexts.indexOf(rule);
+            if (indexOf === -1 || indexOf > lastMatch_1) {
+                try {
+                    (_b = styleNode.sheet) === null || _b === void 0 ? void 0 : _b.deleteRule(Number(index));
+                }
+                catch (e) {
+                }
+            }
+            lastMatch_1 = indexOf;
+        });
+        cssTexts.forEach(function (cssText, index) {
+            var _a, _b, _c;
+            try {
+                if (((_b = (_a = styleNode.sheet) === null || _a === void 0 ? void 0 : _a.cssRules[index]) === null || _b === void 0 ? void 0 : _b.cssText) !== cssText) {
+                    (_c = styleNode.sheet) === null || _c === void 0 ? void 0 : _c.insertRule(cssText, index);
+                }
+            }
+            catch (e) {
+            }
+        });
+    }
+    catch (e) {
+    }
+}
+function storeCSSRules(parentElement, virtualStyleRulesMap) {
+    var _a;
+    try {
+        var cssTexts = Array.from(((_a = parentElement.sheet) === null || _a === void 0 ? void 0 : _a.cssRules) || []).map(function (rule) { return rule.cssText; });
+        virtualStyleRulesMap.set(parentElement, [
+            {
+                type: StyleRuleType.Snapshot,
+                cssTexts: cssTexts,
+            },
+        ]);
+    }
+    catch (e) {
+    }
+}
+
+/*
+ * 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 = 0; i < chars.length; i++) {
+    lookup[chars.charCodeAt(i)] = i;
+}
+var decode = function (base64) {
+    var bufferLength = base64.length * 0.75, len = base64.length, i, p = 0, encoded1, encoded2, encoded3, encoded4;
+    if (base64[base64.length - 1] === '=') {
+        bufferLength--;
+        if (base64[base64.length - 2] === '=') {
+            bufferLength--;
+        }
+    }
+    var arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer);
+    for (i = 0; i < len; i += 4) {
+        encoded1 = lookup[base64.charCodeAt(i)];
+        encoded2 = lookup[base64.charCodeAt(i + 1)];
+        encoded3 = lookup[base64.charCodeAt(i + 2)];
+        encoded4 = lookup[base64.charCodeAt(i + 3)];
+        bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);
+        bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
+        bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);
+    }
+    return arraybuffer;
+};
+
+var webGLVarMap = new Map();
+function variableListFor(ctx, ctor) {
+    var contextMap = webGLVarMap.get(ctx);
+    if (!contextMap) {
+        contextMap = new Map();
+        webGLVarMap.set(ctx, contextMap);
+    }
+    if (!contextMap.has(ctor)) {
+        contextMap.set(ctor, []);
+    }
+    return contextMap.get(ctor);
+}
+function getContext(target, type) {
+    try {
+        if (type === CanvasContext.WebGL) {
+            return (target.getContext('webgl') || target.getContext('experimental-webgl'));
+        }
+        return target.getContext('webgl2');
+    }
+    catch (e) {
+        return null;
+    }
+}
+var WebGLVariableConstructorsNames = [
+    'WebGLActiveInfo',
+    'WebGLBuffer',
+    'WebGLFramebuffer',
+    'WebGLProgram',
+    'WebGLRenderbuffer',
+    'WebGLShader',
+    'WebGLShaderPrecisionFormat',
+    'WebGLTexture',
+    'WebGLUniformLocation',
+    'WebGLVertexArrayObject',
+];
+function saveToWebGLVarMap(ctx, result) {
+    if (!(result === null || result === void 0 ? void 0 : result.constructor))
+        return;
+    var name = result.constructor.name;
+    if (!WebGLVariableConstructorsNames.includes(name))
+        return;
+    var variables = variableListFor(ctx, name);
+    if (!variables.includes(result))
+        variables.push(result);
+}
+function deserializeArg(imageMap, ctx) {
+    return function (arg) {
+        if (arg && typeof arg === 'object' && 'rr_type' in arg) {
+            if ('index' in arg) {
+                var name_1 = arg.rr_type, index = arg.index;
+                return variableListFor(ctx, name_1)[index];
+            }
+            else if ('args' in arg) {
+                var name_2 = arg.rr_type, args = arg.args;
+                var ctor = window[name_2];
+                return new (ctor.bind.apply(ctor, __spreadArray([void 0], __read(args.map(deserializeArg(imageMap, ctx))), false)))();
+            }
+            else if ('base64' in arg) {
+                return decode(arg.base64);
+            }
+            else if ('src' in arg) {
+                var image = imageMap.get(arg.src);
+                if (image) {
+                    return image;
+                }
+                else {
+                    var image_1 = new Image();
+                    image_1.src = arg.src;
+                    imageMap.set(arg.src, image_1);
+                    return image_1;
+                }
+            }
+        }
+        else if (Array.isArray(arg)) {
+            return arg.map(deserializeArg(imageMap, ctx));
+        }
+        return arg;
+    };
+}
+function webglMutation(_a) {
+    var mutation = _a.mutation, target = _a.target, type = _a.type, imageMap = _a.imageMap, errorHandler = _a.errorHandler;
+    try {
+        var ctx = getContext(target, type);
+        if (!ctx)
+            return;
+        if (mutation.setter) {
+            ctx[mutation.property] = mutation.args[0];
+            return;
+        }
+        var original = ctx[mutation.property];
+        var args = mutation.args.map(deserializeArg(imageMap, ctx));
+        var result = original.apply(ctx, args);
+        saveToWebGLVarMap(ctx, result);
+        var debugMode = false;
+        if (debugMode) {
+            if (mutation.property === 'compileShader') {
+                if (!ctx.getShaderParameter(args[0], ctx.COMPILE_STATUS))
+                    console.warn('something went wrong in replay', ctx.getShaderInfoLog(args[0]));
+            }
+            else if (mutation.property === 'linkProgram') {
+                ctx.validateProgram(args[0]);
+                if (!ctx.getProgramParameter(args[0], ctx.LINK_STATUS))
+                    console.warn('something went wrong in replay', ctx.getProgramInfoLog(args[0]));
+            }
+            var webglError = ctx.getError();
+            if (webglError !== ctx.NO_ERROR) {
+                console.warn.apply(console, __spreadArray(['WEBGL ERROR',
+                    webglError,
+                    'on command:',
+                    mutation.property], __read(args), false));
+            }
+        }
+    }
+    catch (error) {
+        errorHandler(mutation, error);
+    }
+}
+
+function canvasMutation$1(_a) {
+    var event = _a.event, mutation = _a.mutation, target = _a.target, imageMap = _a.imageMap, errorHandler = _a.errorHandler;
+    try {
+        var ctx = target.getContext('2d');
+        if (mutation.setter) {
+            ctx[mutation.property] = mutation.args[0];
+            return;
+        }
+        var original = ctx[mutation.property];
+        if (mutation.property === 'drawImage' &&
+            typeof mutation.args[0] === 'string') {
+            var image = imageMap.get(event);
+            mutation.args[0] = image;
+            original.apply(ctx, mutation.args);
+        }
+        else {
+            original.apply(ctx, mutation.args);
+        }
+    }
+    catch (error) {
+        errorHandler(mutation, error);
+    }
+}
+
+function canvasMutation(_a) {
+    var event = _a.event, mutation = _a.mutation, target = _a.target, imageMap = _a.imageMap, errorHandler = _a.errorHandler;
+    try {
+        var mutations = 'commands' in mutation ? mutation.commands : [mutation];
+        if ([CanvasContext.WebGL, CanvasContext.WebGL2].includes(mutation.type)) {
+            return mutations.forEach(function (command) {
+                webglMutation({
+                    mutation: command,
+                    type: mutation.type,
+                    target: target,
+                    imageMap: imageMap,
+                    errorHandler: errorHandler,
+                });
+            });
+        }
+        return mutations.forEach(function (command) {
+            canvasMutation$1({
+                event: event,
+                mutation: command,
+                target: target,
+                imageMap: imageMap,
+                errorHandler: errorHandler,
+            });
+        });
+    }
+    catch (error) {
+        errorHandler(mutation, error);
+    }
+}
+
+var SKIP_TIME_THRESHOLD = 10 * 1000;
+var SKIP_TIME_INTERVAL = 2 * 1000;
+var SKIP_TIME_MIN = 1 * 1000;
+var SKIP_DURATION_LIMIT = 60 * 60 * 1000;
+var mitt = mitt$1 || mittProxy;
+var REPLAY_CONSOLE_PREFIX = '[replayer]';
+var defaultMouseTailConfig = {
+    duration: 500,
+    lineCap: 'round',
+    lineWidth: 3,
+    strokeStyle: 'red',
+};
+function indicatesTouchDevice(e) {
+    return (e.type == EventType.IncrementalSnapshot &&
+        (e.data.source == IncrementalSource.TouchMove ||
+            (e.data.source == IncrementalSource.MouseInteraction &&
+                e.data.type == MouseInteractions.TouchStart)));
+}
+var Replayer = (function () {
+    function Replayer(events, config) {
+        var _this = this;
+        this.mouseTail = null;
+        this.tailPositions = [];
+        this.emitter = mitt();
+        this.activityIntervals = [];
+        this.legacy_missingNodeRetryMap = {};
+        this.cache = createCache();
+        this.imageMap = new Map();
+        this.mirror = createMirror();
+        this.firstFullSnapshot = null;
+        this.newDocumentQueue = [];
+        this.mousePos = null;
+        this.touchActive = null;
+        if (!(config === null || config === void 0 ? void 0 : config.liveMode) && events.length < 2) {
+            throw new Error('Replayer need at least 2 events.');
+        }
+        var defaultConfig = {
+            speed: 1,
+            maxSpeed: 360,
+            root: document.body,
+            loadTimeout: 0,
+            skipInactive: false,
+            showWarning: true,
+            showDebug: false,
+            blockClass: 'highlight-block',
+            liveMode: false,
+            insertStyleRules: [],
+            triggerFocus: true,
+            UNSAFE_replayCanvas: false,
+            pauseAnimation: true,
+            mouseTail: defaultMouseTailConfig,
+            inactiveThreshold: 0.02,
+            inactiveSkipTime: SKIP_TIME_INTERVAL,
+        };
+        this.config = Object.assign({}, defaultConfig, config);
+        this.handleResize = this.handleResize.bind(this);
+        this.getCastFn = this.getCastFn.bind(this);
+        this.applyEventsSynchronously = this.applyEventsSynchronously.bind(this);
+        this.emitter.on(ReplayerEvents.Resize, this.handleResize);
+        this.setupDom();
+        this.treeIndex = new TreeIndex();
+        this.fragmentParentMap = new Map();
+        this.elementStateMap = new Map();
+        this.virtualStyleRulesMap = new Map();
+        this.emitter.on(ReplayerEvents.Flush, function () {
+            var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
+            var _e = _this.treeIndex.flush(), scrollMap = _e.scrollMap, inputMap = _e.inputMap, mutationData = _e.mutationData;
+            _this.fragmentParentMap.forEach(function (parent, frag) {
+                return _this.restoreRealParent(frag, parent);
+            });
+            try {
+                for (var _f = __values(mutationData.texts), _g = _f.next(); !_g.done; _g = _f.next()) {
+                    var d = _g.value;
+                    _this.applyText(d, mutationData);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_g && !_g.done && (_a = _f.return)) _a.call(_f);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            try {
+                for (var _h = __values(_this.virtualStyleRulesMap.keys()), _j = _h.next(); !_j.done; _j = _h.next()) {
+                    var node = _j.value;
+                    _this.restoreNodeSheet(node);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            _this.fragmentParentMap.clear();
+            _this.elementStateMap.clear();
+            _this.virtualStyleRulesMap.clear();
+            try {
+                for (var _k = __values(scrollMap.values()), _l = _k.next(); !_l.done; _l = _k.next()) {
+                    var d = _l.value;
+                    _this.applyScroll(d, true);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_l && !_l.done && (_c = _k.return)) _c.call(_k);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            try {
+                for (var _m = __values(inputMap.values()), _o = _m.next(); !_o.done; _o = _m.next()) {
+                    var d = _o.value;
+                    _this.applyInput(d);
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_o && !_o.done && (_d = _m.return)) _d.call(_m);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        });
+        this.emitter.on(ReplayerEvents.PlayBack, function () {
+            _this.firstFullSnapshot = null;
+            _this.mirror.reset();
+        });
+        var timer = new Timer([], (config === null || config === void 0 ? void 0 : config.speed) || defaultConfig.speed);
+        this.service = createPlayerService({
+            events: events
+                .map(function (e) {
+                if (config && config.unpackFn) {
+                    return config.unpackFn(e);
+                }
+                return e;
+            })
+                .sort(function (a1, a2) { return a1.timestamp - a2.timestamp; }),
+            timer: timer,
+            timeOffset: 0,
+            baselineTime: 0,
+            lastPlayedEvent: null,
+        }, {
+            getCastFn: this.getCastFn,
+            applyEventsSynchronously: this.applyEventsSynchronously,
+            emitter: this.emitter,
+        });
+        this.service.start();
+        this.service.subscribe(function (state) {
+            _this.emitter.emit(ReplayerEvents.StateChange, {
+                player: state,
+            });
+        });
+        this.speedService = createSpeedService({
+            normalSpeed: -1,
+            timer: timer,
+        });
+        this.speedService.start();
+        this.speedService.subscribe(function (state) {
+            _this.emitter.emit(ReplayerEvents.StateChange, {
+                speed: state,
+            });
+        });
+        var firstMeta = this.service.state.context.events.find(function (e) { return e.type === EventType.Meta; });
+        var firstFullsnapshot = this.service.state.context.events.find(function (e) { return e.type === EventType.FullSnapshot; });
+        if (firstMeta) {
+            var _a = firstMeta.data, width_1 = _a.width, height_1 = _a.height;
+            setTimeout(function () {
+                _this.emitter.emit(ReplayerEvents.Resize, {
+                    width: width_1,
+                    height: height_1,
+                });
+            }, 0);
+        }
+        if (firstFullsnapshot) {
+            setTimeout(function () {
+                if (_this.firstFullSnapshot) {
+                    return;
+                }
+                _this.firstFullSnapshot = firstFullsnapshot;
+                _this.rebuildFullSnapshot(firstFullsnapshot);
+                _this.iframe.contentWindow.scrollTo(firstFullsnapshot.data.initialOffset);
+            }, 1);
+        }
+        if (this.service.state.context.events.find(indicatesTouchDevice)) {
+            this.mouse.classList.add('touch-device');
+        }
+    }
+    Object.defineProperty(Replayer.prototype, "timer", {
+        get: function () {
+            return this.service.state.context.timer;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Replayer.prototype.on = function (event, handler) {
+        this.emitter.on(event, handler);
+        return this;
+    };
+    Replayer.prototype.off = function (event, handler) {
+        this.emitter.off(event, handler);
+        return this;
+    };
+    Replayer.prototype.setConfig = function (config) {
+        var _this = this;
+        Object.keys(config).forEach(function (key) {
+            _this.config[key] = config[key];
+        });
+        if (!this.config.skipInactive) {
+            this.backToNormal();
+        }
+        if (typeof config.speed !== 'undefined') {
+            this.speedService.send({
+                type: 'SET_SPEED',
+                payload: {
+                    speed: config.speed,
+                },
+            });
+        }
+        if (typeof config.mouseTail !== 'undefined') {
+            if (config.mouseTail === false) {
+                if (this.mouseTail) {
+                    this.mouseTail.style.display = 'none';
+                }
+            }
+            else {
+                if (!this.mouseTail) {
+                    this.mouseTail = document.createElement('canvas');
+                    this.mouseTail.width = Number.parseFloat(this.iframe.width);
+                    this.mouseTail.height = Number.parseFloat(this.iframe.height);
+                    this.mouseTail.classList.add('replayer-mouse-tail');
+                    this.wrapper.insertBefore(this.mouseTail, this.iframe);
+                }
+                this.mouseTail.style.display = 'inherit';
+            }
+        }
+    };
+    Replayer.prototype.getActivityIntervals = function () {
+        var _this = this;
+        if (this.activityIntervals.length == 0) {
+            var allIntervals = [];
+            var metadata = this.getMetaData();
+            var userInteractionEvents = __spreadArray(__spreadArray([
+                { timestamp: metadata.startTime }
+            ], __read(this.service.state.context.events.filter(function (ev) {
+                return _this.isUserInteraction(ev);
+            })), false), [
+                { timestamp: metadata.endTime },
+            ], false);
+            for (var i = 1; i < userInteractionEvents.length; i++) {
+                var currentInterval_1 = userInteractionEvents[i - 1];
+                var _event = userInteractionEvents[i];
+                if (_event.timestamp - currentInterval_1.timestamp >
+                    SKIP_TIME_THRESHOLD) {
+                    allIntervals.push({
+                        startTime: currentInterval_1.timestamp,
+                        endTime: _event.timestamp,
+                        duration: _event.timestamp - currentInterval_1.timestamp,
+                        active: false,
+                    });
+                }
+                else {
+                    allIntervals.push({
+                        startTime: currentInterval_1.timestamp,
+                        endTime: _event.timestamp,
+                        duration: _event.timestamp - currentInterval_1.timestamp,
+                        active: true,
+                    });
+                }
+            }
+            var mergedIntervals = [];
+            var currentInterval = allIntervals[0];
+            for (var i = 1; i < allIntervals.length; i++) {
+                if (allIntervals[i].active != allIntervals[i - 1].active) {
+                    mergedIntervals.push({
+                        startTime: currentInterval.startTime,
+                        endTime: allIntervals[i - 1].endTime,
+                        duration: allIntervals[i - 1].endTime - currentInterval.startTime,
+                        active: allIntervals[i - 1].active,
+                    });
+                    currentInterval = allIntervals[i];
+                }
+            }
+            if (currentInterval && allIntervals.length > 0) {
+                mergedIntervals.push({
+                    startTime: currentInterval.startTime,
+                    endTime: allIntervals[allIntervals.length - 1].endTime,
+                    duration: allIntervals[allIntervals.length - 1].endTime -
+                        currentInterval.startTime,
+                    active: allIntervals[allIntervals.length - 1].active,
+                });
+            }
+            currentInterval = mergedIntervals[0];
+            for (var i = 1; i < mergedIntervals.length; i++) {
+                if ((!mergedIntervals[i].active &&
+                    mergedIntervals[i].duration >
+                        this.config.inactiveThreshold * metadata.totalTime) ||
+                    (!mergedIntervals[i - 1].active &&
+                        mergedIntervals[i - 1].duration >
+                            this.config.inactiveThreshold * metadata.totalTime)) {
+                    this.activityIntervals.push({
+                        startTime: currentInterval.startTime,
+                        endTime: mergedIntervals[i - 1].endTime,
+                        duration: mergedIntervals[i - 1].endTime - currentInterval.startTime,
+                        active: mergedIntervals[i - 1].active,
+                    });
+                    currentInterval = mergedIntervals[i];
+                }
+            }
+            if (currentInterval && mergedIntervals.length > 0) {
+                this.activityIntervals.push({
+                    startTime: currentInterval.startTime,
+                    endTime: mergedIntervals[mergedIntervals.length - 1].endTime,
+                    duration: mergedIntervals[mergedIntervals.length - 1].endTime -
+                        currentInterval.startTime,
+                    active: mergedIntervals[mergedIntervals.length - 1].active,
+                });
+            }
+        }
+        return this.activityIntervals;
+    };
+    Replayer.prototype.getMetaData = function () {
+        var firstEvent = this.service.state.context.events[0];
+        var lastEvent = this.service.state.context.events[this.service.state.context.events.length - 1];
+        return {
+            startTime: firstEvent.timestamp,
+            endTime: lastEvent.timestamp,
+            totalTime: lastEvent.timestamp - firstEvent.timestamp,
+        };
+    };
+    Replayer.prototype.getCurrentTime = function () {
+        return this.timer.timeOffset + this.getTimeOffset();
+    };
+    Replayer.prototype.getTimeOffset = function () {
+        var _a = this.service.state.context, baselineTime = _a.baselineTime, events = _a.events;
+        return baselineTime - events[0].timestamp;
+    };
+    Replayer.prototype.getMirror = function () {
+        return this.mirror;
+    };
+    Replayer.prototype.play = function (timeOffset) {
+        var _a;
+        if (timeOffset === void 0) { timeOffset = 0; }
+        if (this.service.state.matches('paused')) {
+            this.service.send({ type: 'PLAY', payload: { timeOffset: timeOffset } });
+        }
+        else {
+            this.service.send({ type: 'PAUSE' });
+            this.service.send({ type: 'PLAY', payload: { timeOffset: timeOffset } });
+        }
+        (_a = this.iframe.contentDocument) === null || _a === void 0 ? void 0 : _a.getElementsByTagName('html')[0].classList.remove('rrweb-paused');
+        this.emitter.emit(ReplayerEvents.Start);
+        this.handleInactivity(this.getMetaData().startTime + timeOffset, true);
+    };
+    Replayer.prototype.pause = function (timeOffset) {
+        var _a;
+        if (timeOffset === undefined && this.service.state.matches('playing')) {
+            this.service.send({ type: 'PAUSE' });
+        }
+        if (typeof timeOffset === 'number') {
+            this.play(timeOffset);
+            this.service.send({ type: 'PAUSE' });
+        }
+        (_a = this.iframe.contentDocument) === null || _a === void 0 ? void 0 : _a.getElementsByTagName('html')[0].classList.add('rrweb-paused');
+        this.emitter.emit(ReplayerEvents.Pause);
+    };
+    Replayer.prototype.resume = function (timeOffset) {
+        if (timeOffset === void 0) { timeOffset = 0; }
+        console.warn("The 'resume' will be departed in 1.0. Please use 'play' method which has the same interface.");
+        this.play(timeOffset);
+        this.emitter.emit(ReplayerEvents.Resume);
+    };
+    Replayer.prototype.startLive = function (baselineTime) {
+        this.service.send({ type: 'TO_LIVE', payload: { baselineTime: baselineTime } });
+    };
+    Replayer.prototype.addEvent = function (rawEvent) {
+        var _this = this;
+        var event = this.config.unpackFn
+            ? this.config.unpackFn(rawEvent)
+            : rawEvent;
+        if (indicatesTouchDevice(event)) {
+            this.mouse.classList.add('touch-device');
+        }
+        Promise.resolve().then(function () {
+            return _this.service.send({ type: 'ADD_EVENT', payload: { event: event } });
+        });
+    };
+    Replayer.prototype.replaceEvents = function (events) {
+        var e_5, _a;
+        try {
+            for (var events_1 = __values(events), events_1_1 = events_1.next(); !events_1_1.done; events_1_1 = events_1.next()) {
+                var event_1 = events_1_1.value;
+                if (indicatesTouchDevice(event_1)) {
+                    this.mouse.classList.add('touch-device');
+                    break;
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (events_1_1 && !events_1_1.done && (_a = events_1.return)) _a.call(events_1);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        this.service.send({ type: 'REPLACE_EVENTS', payload: { events: events } });
+    };
+    Replayer.prototype.enableInteract = function () {
+        this.iframe.setAttribute('scrolling', 'auto');
+        this.iframe.style.pointerEvents = 'auto';
+    };
+    Replayer.prototype.disableInteract = function () {
+        this.iframe.setAttribute('scrolling', 'no');
+        this.iframe.style.pointerEvents = 'none';
+    };
+    Replayer.prototype.resetCache = function () {
+        this.cache = createCache();
+    };
+    Replayer.prototype.setupDom = function () {
+        this.wrapper = document.createElement('div');
+        this.wrapper.classList.add('replayer-wrapper');
+        this.config.root.appendChild(this.wrapper);
+        this.mouse = document.createElement('div');
+        this.mouse.classList.add('replayer-mouse');
+        this.wrapper.appendChild(this.mouse);
+        if (this.config.mouseTail !== false) {
+            this.mouseTail = document.createElement('canvas');
+            this.mouseTail.classList.add('replayer-mouse-tail');
+            this.mouseTail.style.display = 'inherit';
+            this.wrapper.appendChild(this.mouseTail);
+        }
+        this.iframe = document.createElement('iframe');
+        var attributes = ['allow-same-origin'];
+        if (this.config.UNSAFE_replayCanvas) {
+            attributes.push('allow-scripts');
+        }
+        this.iframe.style.display = 'none';
+        this.iframe.setAttribute('sandbox', attributes.join(' '));
+        this.disableInteract();
+        this.wrapper.appendChild(this.iframe);
+        if (this.iframe.contentWindow && this.iframe.contentDocument) {
+            polyfill$1(this.iframe.contentWindow, this.iframe.contentDocument);
+            polyfill(this.iframe.contentWindow);
+        }
+    };
+    Replayer.prototype.handleResize = function (dimension) {
+        var e_6, _a;
+        this.iframe.style.display = 'inherit';
+        try {
+            for (var _b = __values([this.mouseTail, this.iframe]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var el = _c.value;
+                if (!el) {
+                    continue;
+                }
+                el.setAttribute('width', String(dimension.width));
+                el.setAttribute('height', String(dimension.height));
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+    };
+    Replayer.prototype.applyEventsSynchronously = function (events) {
+        var e_7, _a;
+        try {
+            for (var events_2 = __values(events), events_2_1 = events_2.next(); !events_2_1.done; events_2_1 = events_2.next()) {
+                var event_2 = events_2_1.value;
+                switch (event_2.type) {
+                    case EventType.DomContentLoaded:
+                    case EventType.Load:
+                    case EventType.Custom:
+                        continue;
+                    case EventType.FullSnapshot:
+                    case EventType.Meta:
+                    case EventType.Plugin:
+                        break;
+                    case EventType.IncrementalSnapshot:
+                        switch (event_2.data.source) {
+                            case IncrementalSource.MediaInteraction:
+                                continue;
+                            default:
+                                break;
+                        }
+                        break;
+                    default:
+                        break;
+                }
+                var castFn = this.getCastFn(event_2, true);
+                castFn();
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (events_2_1 && !events_2_1.done && (_a = events_2.return)) _a.call(events_2);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        if (this.mousePos) {
+            this.moveAndHover(this.mousePos.x, this.mousePos.y, this.mousePos.id, true, this.mousePos.debugData);
+        }
+        this.mousePos = null;
+        if (this.touchActive === true) {
+            this.mouse.classList.add('touch-active');
+        }
+        else if (this.touchActive === false) {
+            this.mouse.classList.remove('touch-active');
+        }
+        this.touchActive = null;
+    };
+    Replayer.prototype.getCastFn = function (event, isSync) {
+        var _this = this;
+        if (isSync === void 0) { isSync = false; }
+        var castFn;
+        switch (event.type) {
+            case EventType.DomContentLoaded:
+            case EventType.Load:
+                break;
+            case EventType.Custom:
+                castFn = function () {
+                    _this.emitter.emit(ReplayerEvents.CustomEvent, event);
+                };
+                break;
+            case EventType.Meta:
+                castFn = function () {
+                    return _this.emitter.emit(ReplayerEvents.Resize, {
+                        width: event.data.width,
+                        height: event.data.height,
+                    });
+                };
+                break;
+            case EventType.FullSnapshot:
+                castFn = function () {
+                    if (_this.firstFullSnapshot) {
+                        if (_this.firstFullSnapshot === event) {
+                            _this.firstFullSnapshot = true;
+                            return;
+                        }
+                    }
+                    else {
+                        _this.firstFullSnapshot = true;
+                    }
+                    _this.rebuildFullSnapshot(event, isSync);
+                    _this.iframe.contentWindow.scrollTo(event.data.initialOffset);
+                };
+                break;
+            case EventType.IncrementalSnapshot:
+                castFn = function () {
+                    var e_8, _a;
+                    _this.applyIncremental(event, isSync);
+                    if (isSync) {
+                        return;
+                    }
+                    _this.handleInactivity(event.timestamp);
+                    if (event === _this.nextUserInteractionEvent) {
+                        _this.nextUserInteractionEvent = null;
+                        _this.backToNormal();
+                    }
+                    if (_this.config.skipInactive && !_this.nextUserInteractionEvent) {
+                        try {
+                            for (var _b = __values(_this.service.state.context.events), _c = _b.next(); !_c.done; _c = _b.next()) {
+                                var _event = _c.value;
+                                if (_event.timestamp <= event.timestamp) {
+                                    continue;
+                                }
+                                if (_this.isUserInteraction(_event)) {
+                                    if (_event.delay - event.delay >
+                                        SKIP_TIME_THRESHOLD *
+                                            _this.speedService.state.context.timer.speed) {
+                                        _this.nextUserInteractionEvent = _event;
+                                    }
+                                    break;
+                                }
+                            }
+                        }
+                        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                        finally {
+                            try {
+                                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                            }
+                            finally { if (e_8) throw e_8.error; }
+                        }
+                        if (_this.nextUserInteractionEvent) {
+                            var skipTime = _this.nextUserInteractionEvent.delay - event.delay;
+                            var payload = {
+                                speed: Math.min(Math.round(skipTime / SKIP_TIME_INTERVAL), _this.config.maxSpeed),
+                            };
+                            _this.speedService.send({ type: 'FAST_FORWARD', payload: payload });
+                            _this.emitter.emit(ReplayerEvents.SkipStart, payload);
+                        }
+                    }
+                };
+                break;
+        }
+        var wrappedCastFn = function () {
+            var e_9, _a;
+            if (castFn) {
+                castFn();
+            }
+            try {
+                for (var _b = __values(_this.config.plugins || []), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var plugin = _c.value;
+                    plugin.handler(event, isSync, { replayer: _this });
+                }
+            }
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_9) throw e_9.error; }
+            }
+            _this.service.send({ type: 'CAST_EVENT', payload: { event: event } });
+            var last_index = _this.service.state.context.events.length - 1;
+            if (event === _this.service.state.context.events[last_index]) {
+                var finish_1 = function () {
+                    if (last_index < _this.service.state.context.events.length - 1) {
+                        return;
+                    }
+                    _this.backToNormal();
+                    _this.service.send('END');
+                    _this.emitter.emit(ReplayerEvents.Finish);
+                };
+                if (event.type === EventType.IncrementalSnapshot &&
+                    event.data.source === IncrementalSource.MouseMove &&
+                    event.data.positions.length) {
+                    setTimeout(function () {
+                        finish_1();
+                    }, Math.max(0, -event.data.positions[0].timeOffset + 50));
+                }
+                else {
+                    finish_1();
+                }
+            }
+            _this.emitter.emit(ReplayerEvents.EventCast, event);
+        };
+        return wrappedCastFn;
+    };
+    Replayer.prototype.handleInactivity = function (timestamp, resetNext) {
+        var e_10, _a;
+        if (timestamp === this.inactiveEndTimestamp || resetNext) {
+            this.inactiveEndTimestamp = null;
+            this.backToNormal();
+        }
+        if (this.config.skipInactive && !this.inactiveEndTimestamp) {
+            try {
+                for (var _b = __values(this.getActivityIntervals()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var interval = _c.value;
+                    if (timestamp >= interval.startTime &&
+                        timestamp < interval.endTime &&
+                        !interval.active) {
+                        this.inactiveEndTimestamp = interval.endTime;
+                        break;
+                    }
+                }
+            }
+            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_10) throw e_10.error; }
+            }
+            if (this.inactiveEndTimestamp) {
+                var skipTime = this.inactiveEndTimestamp - timestamp;
+                var payload = {
+                    speed: (skipTime / SKIP_DURATION_LIMIT) * this.config.inactiveSkipTime <
+                        SKIP_TIME_MIN
+                        ? skipTime / SKIP_TIME_MIN
+                        : Math.round(Math.max(skipTime, SKIP_DURATION_LIMIT) /
+                            this.config.inactiveSkipTime),
+                };
+                this.speedService.send({ type: 'FAST_FORWARD', payload: payload });
+                this.emitter.emit(ReplayerEvents.SkipStart, payload);
+            }
+        }
+    };
+    Replayer.prototype.rebuildFullSnapshot = function (event, isSync) {
+        var e_11, _a;
+        var _this = this;
+        if (isSync === void 0) { isSync = false; }
+        if (!this.iframe.contentDocument) {
+            return console.warn('Looks like your replayer has been destroyed.');
+        }
+        if (Object.keys(this.legacy_missingNodeRetryMap).length) {
+            console.warn('Found unresolved missing node map', this.legacy_missingNodeRetryMap);
+        }
+        this.legacy_missingNodeRetryMap = {};
+        var collected = [];
+        this.mirror.map = rebuild(event.data.node, {
+            doc: this.iframe.contentDocument,
+            afterAppend: function (builtNode) {
+                _this.collectIframeAndAttachDocument(collected, builtNode);
+            },
+            cache: this.cache,
+        })[1];
+        var _loop_1 = function (mutationInQueue, builtNode) {
+            this_1.attachDocumentToIframe(mutationInQueue, builtNode);
+            this_1.newDocumentQueue = this_1.newDocumentQueue.filter(function (m) { return m !== mutationInQueue; });
+        };
+        var this_1 = this;
+        try {
+            for (var collected_1 = __values(collected), collected_1_1 = collected_1.next(); !collected_1_1.done; collected_1_1 = collected_1.next()) {
+                var _b = collected_1_1.value, mutationInQueue = _b.mutationInQueue, builtNode = _b.builtNode;
+                _loop_1(mutationInQueue, builtNode);
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (collected_1_1 && !collected_1_1.done && (_a = collected_1.return)) _a.call(collected_1);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+        var _c = this.iframe.contentDocument, documentElement = _c.documentElement, head = _c.head;
+        this.insertStyleRules(documentElement, head);
+        if (!this.service.state.matches('playing')) {
+            this.iframe.contentDocument
+                .getElementsByTagName('html')[0]
+                .classList.add('rrweb-paused');
+        }
+        this.emitter.emit(ReplayerEvents.FullsnapshotRebuilded, event);
+        if (!isSync) {
+            this.waitForStylesheetLoad();
+        }
+        if (this.config.UNSAFE_replayCanvas) {
+            this.preloadAllImages();
+        }
+    };
+    Replayer.prototype.insertStyleRules = function (documentElement, head) {
+        var styleEl = document.createElement('style');
+        documentElement.insertBefore(styleEl, head);
+        var injectStylesRules = rules(this.config.blockClass).concat(this.config.insertStyleRules);
+        if (this.config.pauseAnimation) {
+            injectStylesRules.push('html.rrweb-paused *, html.rrweb-paused *:before, html.rrweb-paused *:after { animation-play-state: paused !important; }');
+        }
+        for (var idx = 0; idx < injectStylesRules.length; idx++) {
+            styleEl.sheet.insertRule(injectStylesRules[idx], idx);
+        }
+    };
+    Replayer.prototype.attachDocumentToIframe = function (mutation, iframeEl) {
+        var e_12, _a;
+        var _this = this;
+        var collected = [];
+        if (!iframeEl.contentDocument) {
+            var parent_1 = iframeEl.parentNode;
+            while (parent_1) {
+                if (this.fragmentParentMap.has(parent_1)) {
+                    var frag = parent_1;
+                    var realParent = this.fragmentParentMap.get(frag);
+                    this.restoreRealParent(frag, realParent);
+                    break;
+                }
+                parent_1 = parent_1.parentNode;
+            }
+        }
+        buildNodeWithSN(mutation.node, {
+            doc: iframeEl.contentDocument,
+            map: this.mirror.map,
+            hackCss: true,
+            skipChild: false,
+            afterAppend: function (builtNode) {
+                _this.collectIframeAndAttachDocument(collected, builtNode);
+                if (builtNode.__sn.type === NodeType.Element &&
+                    builtNode.__sn.tagName.toUpperCase() === 'HTML') {
+                    var _a = iframeEl.contentDocument, documentElement = _a.documentElement, head = _a.head;
+                    _this.insertStyleRules(documentElement, head);
+                }
+            },
+            cache: this.cache,
+        });
+        var _loop_2 = function (mutationInQueue, builtNode) {
+            this_2.attachDocumentToIframe(mutationInQueue, builtNode);
+            this_2.newDocumentQueue = this_2.newDocumentQueue.filter(function (m) { return m !== mutationInQueue; });
+        };
+        var this_2 = this;
+        try {
+            for (var collected_2 = __values(collected), collected_2_1 = collected_2.next(); !collected_2_1.done; collected_2_1 = collected_2.next()) {
+                var _b = collected_2_1.value, mutationInQueue = _b.mutationInQueue, builtNode = _b.builtNode;
+                _loop_2(mutationInQueue, builtNode);
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (collected_2_1 && !collected_2_1.done && (_a = collected_2.return)) _a.call(collected_2);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
+    };
+    Replayer.prototype.collectIframeAndAttachDocument = function (collected, builtNode) {
+        if (isIframeINode(builtNode)) {
+            var mutationInQueue = this.newDocumentQueue.find(function (m) { return m.parentId === builtNode.__sn.id; });
+            if (mutationInQueue) {
+                collected.push({ mutationInQueue: mutationInQueue, builtNode: builtNode });
+            }
+        }
+    };
+    Replayer.prototype.waitForStylesheetLoad = function () {
+        var _this = this;
+        var _a;
+        var head = (_a = this.iframe.contentDocument) === null || _a === void 0 ? void 0 : _a.head;
+        if (head) {
+            var unloadSheets_1 = new Set();
+            var timer_1;
+            var beforeLoadState_1 = this.service.state;
+            var stateHandler_1 = function () {
+                beforeLoadState_1 = _this.service.state;
+            };
+            this.emitter.on(ReplayerEvents.Start, stateHandler_1);
+            this.emitter.on(ReplayerEvents.Pause, stateHandler_1);
+            var unsubscribe_1 = function () {
+                _this.emitter.off(ReplayerEvents.Start, stateHandler_1);
+                _this.emitter.off(ReplayerEvents.Pause, stateHandler_1);
+            };
+            head
+                .querySelectorAll('link[rel="stylesheet"]')
+                .forEach(function (css) {
+                if (!css.sheet) {
+                    unloadSheets_1.add(css);
+                    css.addEventListener('load', function () {
+                        unloadSheets_1.delete(css);
+                        if (unloadSheets_1.size === 0 && timer_1 !== -1) {
+                            if (beforeLoadState_1.matches('playing')) {
+                                _this.play(_this.getCurrentTime());
+                            }
+                            _this.emitter.emit(ReplayerEvents.LoadStylesheetEnd);
+                            if (timer_1) {
+                                clearTimeout(timer_1);
+                            }
+                            unsubscribe_1();
+                        }
+                    });
+                }
+            });
+            if (unloadSheets_1.size > 0) {
+                this.service.send({ type: 'PAUSE' });
+                this.emitter.emit(ReplayerEvents.LoadStylesheetStart);
+                timer_1 = setTimeout(function () {
+                    if (beforeLoadState_1.matches('playing')) {
+                        _this.play(_this.getCurrentTime());
+                    }
+                    timer_1 = -1;
+                    unsubscribe_1();
+                }, this.config.loadTimeout);
+            }
+        }
+    };
+    Replayer.prototype.hasImageArg = function (args) {
+        var e_13, _a;
+        try {
+            for (var args_1 = __values(args), args_1_1 = args_1.next(); !args_1_1.done; args_1_1 = args_1.next()) {
+                var arg = args_1_1.value;
+                if (!arg || typeof arg !== 'object') {
+                }
+                else if ('rr_type' in arg && 'args' in arg) {
+                    if (this.hasImageArg(arg.args))
+                        return true;
+                }
+                else if ('rr_type' in arg && arg.rr_type === 'HTMLImageElement') {
+                    return true;
+                }
+                else if (arg instanceof Array) {
+                    if (this.hasImageArg(arg))
+                        return true;
+                }
+            }
+        }
+        catch (e_13_1) { e_13 = { error: e_13_1 }; }
+        finally {
+            try {
+                if (args_1_1 && !args_1_1.done && (_a = args_1.return)) _a.call(args_1);
+            }
+            finally { if (e_13) throw e_13.error; }
+        }
+        return false;
+    };
+    Replayer.prototype.getImageArgs = function (args) {
+        var e_14, _a;
+        var images = [];
+        try {
+            for (var args_2 = __values(args), args_2_1 = args_2.next(); !args_2_1.done; args_2_1 = args_2.next()) {
+                var arg = args_2_1.value;
+                if (!arg || typeof arg !== 'object') {
+                }
+                else if ('rr_type' in arg && 'args' in arg) {
+                    images.push.apply(images, __spreadArray([], __read(this.getImageArgs(arg.args)), false));
+                }
+                else if ('rr_type' in arg && arg.rr_type === 'HTMLImageElement') {
+                    images.push(arg.src);
+                }
+                else if (arg instanceof Array) {
+                    images.push.apply(images, __spreadArray([], __read(this.getImageArgs(arg)), false));
+                }
+            }
+        }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        finally {
+            try {
+                if (args_2_1 && !args_2_1.done && (_a = args_2.return)) _a.call(args_2);
+            }
+            finally { if (e_14) throw e_14.error; }
+        }
+        return images;
+    };
+    Replayer.prototype.preloadAllImages = function () {
+        var e_15, _a;
+        var _this = this;
+        this.service.state;
+        var stateHandler = function () {
+            _this.service.state;
+        };
+        this.emitter.on(ReplayerEvents.Start, stateHandler);
+        this.emitter.on(ReplayerEvents.Pause, stateHandler);
+        var _loop_3 = function (event_3) {
+            if (event_3.type === EventType.IncrementalSnapshot &&
+                event_3.data.source === IncrementalSource.CanvasMutation)
+                if ('commands' in event_3.data) {
+                    event_3.data.commands.forEach(function (c) { return _this.preloadImages(c, event_3); });
+                }
+                else {
+                    this_3.preloadImages(event_3.data, event_3);
+                }
+        };
+        var this_3 = this;
+        try {
+            for (var _b = __values(this.service.state.context.events), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var event_3 = _c.value;
+                _loop_3(event_3);
+            }
+        }
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_15) throw e_15.error; }
+        }
+    };
+    Replayer.prototype.preloadImages = function (data, event) {
+        var _this = this;
+        if (data.property === 'drawImage' &&
+            typeof data.args[0] === 'string' &&
+            !this.imageMap.has(event)) {
+            var canvas = document.createElement('canvas');
+            var ctx = canvas.getContext('2d');
+            var imgd = ctx === null || ctx === void 0 ? void 0 : ctx.createImageData(canvas.width, canvas.height);
+            imgd === null || imgd === void 0 ? void 0 : imgd.data;
+            JSON.parse(data.args[0]);
+            ctx === null || ctx === void 0 ? void 0 : ctx.putImageData(imgd, 0, 0);
+        }
+        else if (this.hasImageArg(data.args)) {
+            this.getImageArgs(data.args).forEach(function (url) {
+                var image = new Image();
+                image.src = url;
+                _this.imageMap.set(url, image);
+            });
+        }
+    };
+    Replayer.prototype.applyIncremental = function (e, isSync) {
+        var _this = this;
+        var _a, _b;
+        var d = e.data;
+        switch (d.source) {
+            case IncrementalSource.Mutation: {
+                if (isSync) {
+                    d.adds.forEach(function (m) { return _this.treeIndex.add(m); });
+                    d.texts.forEach(function (m) {
+                        var target = _this.mirror.getNode(m.id);
+                        var parent = target === null || target === void 0 ? void 0 : target.parentNode;
+                        if (parent && _this.virtualStyleRulesMap.has(parent))
+                            _this.virtualStyleRulesMap.delete(parent);
+                        _this.treeIndex.text(m);
+                    });
+                    d.attributes.forEach(function (m) { return _this.treeIndex.attribute(m); });
+                    d.removes.forEach(function (m) { return _this.treeIndex.remove(m, _this.mirror); });
+                }
+                try {
+                    this.applyMutation(d, isSync);
+                }
+                catch (error) {
+                    this.warn("Exception in mutation ".concat(error.message || error), d);
+                }
+                break;
+            }
+            case IncrementalSource.Drag:
+            case IncrementalSource.TouchMove:
+            case IncrementalSource.MouseMove:
+                if (isSync) {
+                    var lastPosition = d.positions[d.positions.length - 1];
+                    this.mousePos = {
+                        x: lastPosition.x,
+                        y: lastPosition.y,
+                        id: lastPosition.id,
+                        debugData: d,
+                    };
+                }
+                else {
+                    d.positions.forEach(function (p) {
+                        var action = {
+                            doAction: function () {
+                                _this.moveAndHover(p.x, p.y, p.id, isSync, d);
+                            },
+                            delay: p.timeOffset +
+                                e.timestamp -
+                                _this.service.state.context.baselineTime,
+                        };
+                        _this.timer.addAction(action);
+                    });
+                    this.timer.addAction({
+                        doAction: function () { },
+                        delay: e.delay - ((_a = d.positions[0]) === null || _a === void 0 ? void 0 : _a.timeOffset),
+                    });
+                }
+                break;
+            case IncrementalSource.MouseInteraction: {
+                if (d.id === -1) {
+                    break;
+                }
+                var event_4 = new Event(MouseInteractions[d.type].toLowerCase());
+                var target = this.mirror.getNode(d.id);
+                if (!target) {
+                    return this.debugNodeNotFound(d, d.id);
+                }
+                this.emitter.emit(ReplayerEvents.MouseInteraction, {
+                    type: d.type,
+                    target: target,
+                });
+                var triggerFocus = this.config.triggerFocus;
+                switch (d.type) {
+                    case MouseInteractions.Blur:
+                        if ('blur' in target) {
+                            target.blur();
+                        }
+                        break;
+                    case MouseInteractions.Focus:
+                        if (triggerFocus && target.focus) {
+                            target.focus({
+                                preventScroll: true,
+                            });
+                        }
+                        break;
+                    case MouseInteractions.Click:
+                    case MouseInteractions.TouchStart:
+                    case MouseInteractions.TouchEnd:
+                        if (isSync) {
+                            if (d.type === MouseInteractions.TouchStart) {
+                                this.touchActive = true;
+                            }
+                            else if (d.type === MouseInteractions.TouchEnd) {
+                                this.touchActive = false;
+                            }
+                            this.mousePos = {
+                                x: d.x,
+                                y: d.y,
+                                id: d.id,
+                                debugData: d,
+                            };
+                        }
+                        else {
+                            if (d.type === MouseInteractions.TouchStart) {
+                                this.tailPositions.length = 0;
+                            }
+                            this.moveAndHover(d.x, d.y, d.id, isSync, d);
+                            if (d.type === MouseInteractions.Click) {
+                                this.mouse.classList.remove('active');
+                                void this.mouse.offsetWidth;
+                                this.mouse.classList.add('active');
+                            }
+                            else if (d.type === MouseInteractions.TouchStart) {
+                                void this.mouse.offsetWidth;
+                                this.mouse.classList.add('touch-active');
+                            }
+                            else if (d.type === MouseInteractions.TouchEnd) {
+                                this.mouse.classList.remove('touch-active');
+                            }
+                        }
+                        break;
+                    case MouseInteractions.TouchCancel:
+                        if (isSync) {
+                            this.touchActive = false;
+                        }
+                        else {
+                            this.mouse.classList.remove('touch-active');
+                        }
+                        break;
+                    default:
+                        target.dispatchEvent(event_4);
+                }
+                break;
+            }
+            case IncrementalSource.Scroll: {
+                if (d.id === -1) {
+                    break;
+                }
+                if (isSync) {
+                    this.treeIndex.scroll(d);
+                    break;
+                }
+                this.applyScroll(d, false);
+                break;
+            }
+            case IncrementalSource.ViewportResize:
+                this.emitter.emit(ReplayerEvents.Resize, {
+                    width: d.width,
+                    height: d.height,
+                });
+                break;
+            case IncrementalSource.Input: {
+                if (d.id === -1) {
+                    break;
+                }
+                if (isSync) {
+                    this.treeIndex.input(d);
+                    break;
+                }
+                this.applyInput(d);
+                break;
+            }
+            case IncrementalSource.MediaInteraction: {
+                var target = this.mirror.getNode(d.id);
+                if (!target) {
+                    return this.debugNodeNotFound(d, d.id);
+                }
+                var mediaEl = target;
+                try {
+                    if (d.currentTime) {
+                        mediaEl.currentTime = d.currentTime;
+                    }
+                    if (d.volume) {
+                        mediaEl.volume = d.volume;
+                    }
+                    if (d.muted) {
+                        mediaEl.muted = d.muted;
+                    }
+                    if (d.type === 1) {
+                        mediaEl.pause();
+                    }
+                    if (d.type === 0) {
+                        mediaEl.play();
+                    }
+                }
+                catch (error) {
+                    if (this.config.showWarning) {
+                        console.warn("Failed to replay media interactions: ".concat(error.message || error));
+                    }
+                }
+                break;
+            }
+            case IncrementalSource.StyleSheetRule: {
+                var target = this.mirror.getNode(d.id);
+                if (!target) {
+                    return this.debugNodeNotFound(d, d.id);
+                }
+                var styleEl = target;
+                var parent_2 = target.parentNode;
+                var usingVirtualParent_1 = this.fragmentParentMap.has(parent_2);
+                var styleSheet_1 = usingVirtualParent_1 ? null : styleEl.sheet;
+                var rules_1;
+                if (!styleSheet_1) {
+                    if (this.virtualStyleRulesMap.has(target)) {
+                        rules_1 = this.virtualStyleRulesMap.get(target);
+                    }
+                    else {
+                        rules_1 = [];
+                        this.virtualStyleRulesMap.set(target, rules_1);
+                    }
+                }
+                if (d.adds) {
+                    d.adds.forEach(function (_a) {
+                        var rule = _a.rule, nestedIndex = _a.index;
+                        if (styleSheet_1) {
+                            try {
+                                if (Array.isArray(nestedIndex)) {
+                                    var _b = getPositionsAndIndex(nestedIndex), positions = _b.positions, index = _b.index;
+                                    var nestedRule = getNestedRule(styleSheet_1.cssRules, positions);
+                                    nestedRule.insertRule(rule, index);
+                                }
+                                else {
+                                    var index = nestedIndex === undefined
+                                        ? undefined
+                                        : Math.min(nestedIndex, styleSheet_1.cssRules.length);
+                                    styleSheet_1.insertRule(rule, index);
+                                }
+                            }
+                            catch (e) {
+                            }
+                        }
+                        else {
+                            rules_1 === null || rules_1 === void 0 ? void 0 : rules_1.push({
+                                cssText: rule,
+                                index: nestedIndex,
+                                type: StyleRuleType.Insert,
+                            });
+                        }
+                    });
+                }
+                if (d.removes) {
+                    d.removes.forEach(function (_a) {
+                        var nestedIndex = _a.index;
+                        if (usingVirtualParent_1) {
+                            rules_1 === null || rules_1 === void 0 ? void 0 : rules_1.push({ index: nestedIndex, type: StyleRuleType.Remove });
+                        }
+                        else {
+                            try {
+                                if (Array.isArray(nestedIndex)) {
+                                    var _b = getPositionsAndIndex(nestedIndex), positions = _b.positions, index = _b.index;
+                                    var nestedRule = getNestedRule(styleSheet_1.cssRules, positions);
+                                    nestedRule.deleteRule(index || 0);
+                                }
+                                else {
+                                    styleSheet_1 === null || styleSheet_1 === void 0 ? void 0 : styleSheet_1.deleteRule(nestedIndex);
+                                }
+                            }
+                            catch (e) {
+                            }
+                        }
+                    });
+                }
+                break;
+            }
+            case IncrementalSource.StyleDeclaration: {
+                var target = this.mirror.getNode(d.id);
+                if (!target) {
+                    return this.debugNodeNotFound(d, d.id);
+                }
+                var styleEl = target;
+                var parent_3 = target.parentNode;
+                var usingVirtualParent = this.fragmentParentMap.has(parent_3);
+                var styleSheet = usingVirtualParent ? null : styleEl.sheet;
+                var rules = [];
+                if (!styleSheet) {
+                    if (this.virtualStyleRulesMap.has(target)) {
+                        rules = this.virtualStyleRulesMap.get(target);
+                    }
+                    else {
+                        rules = [];
+                        this.virtualStyleRulesMap.set(target, rules);
+                    }
+                }
+                if (d.set) {
+                    if (styleSheet) {
+                        var rule = getNestedRule(styleSheet.rules, d.index);
+                        rule.style.setProperty(d.set.property, d.set.value, d.set.priority);
+                    }
+                    else {
+                        rules.push(__assign({ type: StyleRuleType.SetProperty, index: d.index }, d.set));
+                    }
+                }
+                if (d.remove) {
+                    if (styleSheet) {
+                        var rule = getNestedRule(styleSheet.rules, d.index);
+                        rule.style.removeProperty(d.remove.property);
+                    }
+                    else {
+                        rules.push(__assign({ type: StyleRuleType.RemoveProperty, index: d.index }, d.remove));
+                    }
+                }
+                break;
+            }
+            case IncrementalSource.CanvasMutation: {
+                if (!this.config.UNSAFE_replayCanvas) {
+                    return;
+                }
+                var target = this.mirror.getNode(d.id);
+                if (!target) {
+                    return this.debugNodeNotFound(d, d.id);
+                }
+                canvasMutation({
+                    event: e,
+                    mutation: d,
+                    target: target,
+                    imageMap: this.imageMap,
+                    errorHandler: this.warnCanvasMutationFailed.bind(this),
+                });
+                break;
+            }
+            case IncrementalSource.Font: {
+                try {
+                    var fontFace = new FontFace(d.family, d.buffer ? new Uint8Array(JSON.parse(d.fontSource)) : d.fontSource, d.descriptors);
+                    (_b = this.iframe.contentDocument) === null || _b === void 0 ? void 0 : _b.fonts.add(fontFace);
+                }
+                catch (error) {
+                    if (this.config.showWarning) {
+                        console.warn(error);
+                    }
+                }
+                break;
+            }
+        }
+    };
+    Replayer.prototype.applyMutation = function (d, useVirtualParent) {
+        var e_16, _a;
+        var _this = this;
+        d.removes.forEach(function (mutation) {
+            var target = _this.mirror.getNode(mutation.id);
+            if (!target) {
+                if (d.removes.find(function (r) { return r.id === mutation.parentId; })) {
+                    return;
+                }
+                return _this.warnNodeNotFound(d, mutation.id);
+            }
+            if (_this.virtualStyleRulesMap.has(target)) {
+                _this.virtualStyleRulesMap.delete(target);
+            }
+            var parent = _this.mirror.getNode(mutation.parentId);
+            if (!parent) {
+                return _this.warnNodeNotFound(d, mutation.parentId);
+            }
+            if (mutation.isShadow && hasShadowRoot(parent)) {
+                parent = parent.shadowRoot;
+            }
+            _this.mirror.removeNodeFromMap(target);
+            if (parent) {
+                var realTarget = null;
+                var realParent = '__sn' in parent ? _this.fragmentParentMap.get(parent) : undefined;
+                if (realParent && realParent.contains(target)) {
+                    parent = realParent;
+                }
+                else if (_this.fragmentParentMap.has(target)) {
+                    realTarget = _this.fragmentParentMap.get(target);
+                    _this.fragmentParentMap.delete(target);
+                    target = realTarget;
+                }
+                try {
+                    parent.removeChild(target);
+                }
+                catch (error) {
+                    if (error instanceof DOMException) {
+                        _this.warn('parent could not remove child in mutation', parent, realParent, target, realTarget, d);
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+        });
+        var legacy_missingNodeMap = __assign({}, this.legacy_missingNodeRetryMap);
+        var queue = [];
+        var nextNotInDOM = function (mutation) {
+            var next = null;
+            if (mutation.nextId) {
+                next = _this.mirror.getNode(mutation.nextId);
+            }
+            if (mutation.nextId !== null &&
+                mutation.nextId !== undefined &&
+                mutation.nextId !== -1 &&
+                !next) {
+                return true;
+            }
+            return false;
+        };
+        var appendNode = function (mutation) {
+            var e_17, _a;
+            var _b, _c;
+            if (!_this.iframe.contentDocument) {
+                return console.warn('Looks like your replayer has been destroyed.');
+            }
+            var parent = _this.mirror.getNode(mutation.parentId);
+            if (!parent) {
+                if (mutation.node.type === NodeType.Document) {
+                    return _this.newDocumentQueue.push(mutation);
+                }
+                return queue.push(mutation);
+            }
+            var parentInDocument = null;
+            if (_this.iframe.contentDocument.contains) {
+                parentInDocument = _this.iframe.contentDocument.contains(parent);
+            }
+            else if (_this.iframe.contentDocument.body.contains) {
+                parentInDocument = _this.iframe.contentDocument.body.contains(parent);
+            }
+            var hasIframeChild = ((_c = (_b = parent).getElementsByTagName) === null || _c === void 0 ? void 0 : _c.call(_b, 'iframe').length) > 0;
+            if (useVirtualParent &&
+                parentInDocument &&
+                !isIframeINode(parent) &&
+                !hasIframeChild) {
+                var virtualParent = document.createDocumentFragment();
+                _this.mirror.map[mutation.parentId] = virtualParent;
+                _this.fragmentParentMap.set(virtualParent, parent);
+                _this.storeState(parent);
+                while (parent.firstChild) {
+                    virtualParent.appendChild(parent.firstChild);
+                }
+                parent = virtualParent;
+            }
+            if (mutation.node.isShadow) {
+                if (!hasShadowRoot(parent)) {
+                    parent.attachShadow({ mode: 'open' });
+                    parent = parent.shadowRoot;
+                }
+                else
+                    parent = parent.shadowRoot;
+            }
+            var previous = null;
+            var next = null;
+            if (mutation.previousId) {
+                previous = _this.mirror.getNode(mutation.previousId);
+            }
+            if (mutation.nextId) {
+                next = _this.mirror.getNode(mutation.nextId);
+            }
+            if (nextNotInDOM(mutation)) {
+                return queue.push(mutation);
+            }
+            if (mutation.node.rootId && !_this.mirror.getNode(mutation.node.rootId)) {
+                return;
+            }
+            var targetDoc = mutation.node.rootId
+                ? _this.mirror.getNode(mutation.node.rootId)
+                : _this.iframe.contentDocument;
+            if (isIframeINode(parent)) {
+                _this.attachDocumentToIframe(mutation, parent);
+                return;
+            }
+            var target = buildNodeWithSN(mutation.node, {
+                doc: targetDoc,
+                map: _this.mirror.map,
+                skipChild: true,
+                hackCss: true,
+                cache: _this.cache,
+            });
+            if (mutation.previousId === -1 || mutation.nextId === -1) {
+                legacy_missingNodeMap[mutation.node.id] = {
+                    node: target,
+                    mutation: mutation,
+                };
+                return;
+            }
+            if ('__sn' in parent &&
+                parent.__sn.type === NodeType.Element &&
+                parent.__sn.tagName === 'textarea' &&
+                mutation.node.type === NodeType.Text) {
+                try {
+                    for (var _d = __values(Array.from(parent.childNodes)), _e = _d.next(); !_e.done; _e = _d.next()) {
+                        var c = _e.value;
+                        if (c.nodeType === parent.TEXT_NODE) {
+                            parent.removeChild(c);
+                        }
+                    }
+                }
+                catch (e_17_1) { e_17 = { error: e_17_1 }; }
+                finally {
+                    try {
+                        if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                    }
+                    finally { if (e_17) throw e_17.error; }
+                }
+            }
+            if (previous && previous.nextSibling && previous.nextSibling.parentNode) {
+                parent.insertBefore(target, previous.nextSibling);
+            }
+            else if (next && next.parentNode) {
+                parent.contains(next)
+                    ? parent.insertBefore(target, next)
+                    : parent.insertBefore(target, null);
+            }
+            else {
+                if (parent === targetDoc) {
+                    while (targetDoc.firstChild) {
+                        targetDoc.removeChild(targetDoc.firstChild);
+                    }
+                }
+                parent.appendChild(target);
+            }
+            if (isIframeINode(target)) {
+                var mutationInQueue_1 = _this.newDocumentQueue.find(function (m) { return m.parentId === target.__sn.id; });
+                if (mutationInQueue_1) {
+                    _this.attachDocumentToIframe(mutationInQueue_1, target);
+                    _this.newDocumentQueue = _this.newDocumentQueue.filter(function (m) { return m !== mutationInQueue_1; });
+                }
+            }
+            if (mutation.previousId || mutation.nextId) {
+                _this.legacy_resolveMissingNode(legacy_missingNodeMap, parent, target, mutation);
+            }
+        };
+        d.adds.forEach(function (mutation) {
+            appendNode(mutation);
+        });
+        var startTime = Date.now();
+        while (queue.length) {
+            var resolveTrees = queueToResolveTrees(queue);
+            queue.length = 0;
+            if (Date.now() - startTime > 500) {
+                this.warn('Timeout in the loop, please check the resolve tree data:', resolveTrees);
+                break;
+            }
+            try {
+                for (var resolveTrees_1 = (e_16 = void 0, __values(resolveTrees)), resolveTrees_1_1 = resolveTrees_1.next(); !resolveTrees_1_1.done; resolveTrees_1_1 = resolveTrees_1.next()) {
+                    var tree = resolveTrees_1_1.value;
+                    var parent_4 = this.mirror.getNode(tree.value.parentId);
+                    if (!parent_4) {
+                        this.debug('Drop resolve tree since there is no parent for the root node.', tree);
+                    }
+                    else {
+                        iterateResolveTree(tree, function (mutation) {
+                            appendNode(mutation);
+                        });
+                    }
+                }
+            }
+            catch (e_16_1) { e_16 = { error: e_16_1 }; }
+            finally {
+                try {
+                    if (resolveTrees_1_1 && !resolveTrees_1_1.done && (_a = resolveTrees_1.return)) _a.call(resolveTrees_1);
+                }
+                finally { if (e_16) throw e_16.error; }
+            }
+        }
+        if (Object.keys(legacy_missingNodeMap).length) {
+            Object.assign(this.legacy_missingNodeRetryMap, legacy_missingNodeMap);
+        }
+        d.texts.forEach(function (mutation) {
+            var target = _this.mirror.getNode(mutation.id);
+            if (!target) {
+                if (d.removes.find(function (r) { return r.id === mutation.id; })) {
+                    return;
+                }
+                return _this.warnNodeNotFound(d, mutation.id);
+            }
+            if (_this.fragmentParentMap.has(target)) {
+                target = _this.fragmentParentMap.get(target);
+            }
+            target.textContent = mutation.value;
+        });
+        d.attributes.forEach(function (mutation) {
+            var target = _this.mirror.getNode(mutation.id);
+            if (!target) {
+                if (d.removes.find(function (r) { return r.id === mutation.id; })) {
+                    return;
+                }
+                return _this.warnNodeNotFound(d, mutation.id);
+            }
+            if (_this.fragmentParentMap.has(target)) {
+                target = _this.fragmentParentMap.get(target);
+            }
+            for (var attributeName in mutation.attributes) {
+                if (typeof attributeName === 'string') {
+                    var value = mutation.attributes[attributeName];
+                    if (value === null) {
+                        target.removeAttribute(attributeName);
+                    }
+                    else if (typeof value === 'string') {
+                        try {
+                            target.setAttribute(attributeName, value);
+                        }
+                        catch (error) {
+                            if (_this.config.showWarning) {
+                                console.warn('An error occurred may due to the checkout feature.', error);
+                            }
+                        }
+                    }
+                    else if (attributeName === 'style') {
+                        var styleValues = value;
+                        var targetEl = target;
+                        for (var s in styleValues) {
+                            if (styleValues[s] === false) {
+                                targetEl.style.removeProperty(s);
+                            }
+                            else if (styleValues[s] instanceof Array) {
+                                var svp = styleValues[s];
+                                targetEl.style.setProperty(s, svp[0], svp[1]);
+                            }
+                            else {
+                                var svs = styleValues[s];
+                                targetEl.style.setProperty(s, svs);
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    };
+    Replayer.prototype.applyScroll = function (d, isSync) {
+        var target = this.mirror.getNode(d.id);
+        if (!target) {
+            return this.debugNodeNotFound(d, d.id);
+        }
+        if (target === this.iframe.contentDocument) {
+            this.iframe.contentWindow.scrollTo({
+                top: d.y,
+                left: d.x,
+                behavior: isSync ? 'auto' : 'smooth',
+            });
+        }
+        else if (target.__sn.type === NodeType.Document) {
+            target.defaultView.scrollTo({
+                top: d.y,
+                left: d.x,
+                behavior: isSync ? 'auto' : 'smooth',
+            });
+        }
+        else {
+            try {
+                target.scrollTop = d.y;
+                target.scrollLeft = d.x;
+            }
+            catch (error) {
+            }
+        }
+    };
+    Replayer.prototype.applyInput = function (d) {
+        var target = this.mirror.getNode(d.id);
+        if (!target) {
+            return this.debugNodeNotFound(d, d.id);
+        }
+        try {
+            target.checked = d.isChecked;
+            target.value = d.text;
+        }
+        catch (error) {
+        }
+    };
+    Replayer.prototype.applyText = function (d, mutation) {
+        var target = this.mirror.getNode(d.id);
+        if (!target) {
+            return this.debugNodeNotFound(mutation, d.id);
+        }
+        try {
+            target.textContent = d.value;
+        }
+        catch (error) {
+        }
+    };
+    Replayer.prototype.legacy_resolveMissingNode = function (map, parent, target, targetMutation) {
+        var previousId = targetMutation.previousId, nextId = targetMutation.nextId;
+        var previousInMap = previousId && map[previousId];
+        var nextInMap = nextId && map[nextId];
+        if (previousInMap) {
+            var _a = previousInMap, node = _a.node, mutation = _a.mutation;
+            parent.insertBefore(node, target);
+            delete map[mutation.node.id];
+            delete this.legacy_missingNodeRetryMap[mutation.node.id];
+            if (mutation.previousId || mutation.nextId) {
+                this.legacy_resolveMissingNode(map, parent, node, mutation);
+            }
+        }
+        if (nextInMap) {
+            var _b = nextInMap, node = _b.node, mutation = _b.mutation;
+            parent.insertBefore(node, target.nextSibling);
+            delete map[mutation.node.id];
+            delete this.legacy_missingNodeRetryMap[mutation.node.id];
+            if (mutation.previousId || mutation.nextId) {
+                this.legacy_resolveMissingNode(map, parent, node, mutation);
+            }
+        }
+    };
+    Replayer.prototype.moveAndHover = function (x, y, id, isSync, debugData) {
+        var target = this.mirror.getNode(id);
+        if (!target) {
+            return this.debugNodeNotFound(debugData, id);
+        }
+        var base = getBaseDimension(target, this.iframe);
+        var _x = x * base.absoluteScale + base.x;
+        var _y = y * base.absoluteScale + base.y;
+        this.mouse.style.left = "".concat(_x, "px");
+        this.mouse.style.top = "".concat(_y, "px");
+        if (!isSync) {
+            this.drawMouseTail({ x: _x, y: _y });
+        }
+        this.hoverElements(target);
+    };
+    Replayer.prototype.drawMouseTail = function (position) {
+        var _this = this;
+        if (!this.mouseTail) {
+            return;
+        }
+        var _a = this.config.mouseTail === true
+            ? defaultMouseTailConfig
+            : Object.assign({}, defaultMouseTailConfig, this.config.mouseTail), lineCap = _a.lineCap, lineWidth = _a.lineWidth, strokeStyle = _a.strokeStyle, duration = _a.duration;
+        var draw = function () {
+            if (!_this.mouseTail) {
+                return;
+            }
+            var ctx = _this.mouseTail.getContext('2d');
+            if (!ctx || !_this.tailPositions.length) {
+                return;
+            }
+            ctx.clearRect(0, 0, _this.mouseTail.width, _this.mouseTail.height);
+            ctx.beginPath();
+            ctx.lineWidth = lineWidth;
+            ctx.lineCap = lineCap;
+            ctx.strokeStyle = strokeStyle;
+            ctx.moveTo(_this.tailPositions[0].x, _this.tailPositions[0].y);
+            _this.tailPositions.forEach(function (p) { return ctx.lineTo(p.x, p.y); });
+            ctx.stroke();
+        };
+        this.tailPositions.push(position);
+        draw();
+        setTimeout(function () {
+            _this.tailPositions = _this.tailPositions.filter(function (p) { return p !== position; });
+            draw();
+        }, duration / this.speedService.state.context.timer.speed);
+    };
+    Replayer.prototype.hoverElements = function (el) {
+        var _a;
+        (_a = this.iframe.contentDocument) === null || _a === void 0 ? void 0 : _a.querySelectorAll('.\\:hover').forEach(function (hoveredEl) {
+            hoveredEl.classList.remove(':hover');
+        });
+        var currentEl = el;
+        while (currentEl) {
+            if (currentEl.classList) {
+                currentEl.classList.add(':hover');
+            }
+            currentEl = currentEl.parentElement;
+        }
+    };
+    Replayer.prototype.isUserInteraction = function (event) {
+        if (event.type !== EventType.IncrementalSnapshot) {
+            return false;
+        }
+        return (event.data.source > IncrementalSource.Mutation &&
+            event.data.source <= IncrementalSource.Input);
+    };
+    Replayer.prototype.backToNormal = function () {
+        this.nextUserInteractionEvent = null;
+        if (this.speedService.state.matches('normal')) {
+            return;
+        }
+        this.speedService.send({ type: 'BACK_TO_NORMAL' });
+        this.emitter.emit(ReplayerEvents.SkipEnd, {
+            speed: this.speedService.state.context.normalSpeed,
+        });
+    };
+    Replayer.prototype.restoreRealParent = function (frag, parent) {
+        this.mirror.map[parent.__sn.id] = parent;
+        if (parent.__sn.type === NodeType.Element &&
+            parent.__sn.tagName === 'textarea' &&
+            frag.textContent) {
+            parent.value = frag.textContent;
+        }
+        parent.appendChild(frag);
+        this.restoreState(parent);
+    };
+    Replayer.prototype.storeState = function (parent) {
+        var e_18, _a;
+        if (parent) {
+            if (parent.nodeType === parent.ELEMENT_NODE) {
+                var parentElement = parent;
+                if (parentElement.scrollLeft || parentElement.scrollTop) {
+                    this.elementStateMap.set(parent, {
+                        scroll: [parentElement.scrollLeft, parentElement.scrollTop],
+                    });
+                }
+                if (parentElement.tagName === 'STYLE')
+                    storeCSSRules(parentElement, this.virtualStyleRulesMap);
+                var children = parentElement.children;
+                try {
+                    for (var _b = __values(Array.from(children)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var child = _c.value;
+                        this.storeState(child);
+                    }
+                }
+                catch (e_18_1) { e_18 = { error: e_18_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_18) throw e_18.error; }
+                }
+            }
+        }
+    };
+    Replayer.prototype.restoreState = function (parent) {
+        var e_19, _a;
+        if (parent.nodeType === parent.ELEMENT_NODE) {
+            var parentElement = parent;
+            if (this.elementStateMap.has(parent)) {
+                var storedState = this.elementStateMap.get(parent);
+                if (storedState.scroll) {
+                    parentElement.scrollLeft = storedState.scroll[0];
+                    parentElement.scrollTop = storedState.scroll[1];
+                }
+                this.elementStateMap.delete(parent);
+            }
+            var children = parentElement.children;
+            try {
+                for (var _b = __values(Array.from(children)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var child = _c.value;
+                    this.restoreState(child);
+                }
+            }
+            catch (e_19_1) { e_19 = { error: e_19_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_19) throw e_19.error; }
+            }
+        }
+    };
+    Replayer.prototype.restoreNodeSheet = function (node) {
+        var storedRules = this.virtualStyleRulesMap.get(node);
+        if (node.nodeName !== 'STYLE') {
+            return;
+        }
+        if (!storedRules) {
+            return;
+        }
+        var styleNode = node;
+        applyVirtualStyleRulesToNode(storedRules, styleNode);
+    };
+    Replayer.prototype.warnNodeNotFound = function (d, id) {
+        if (this.treeIndex.idRemoved(id)) {
+            this.warn("Node with id '".concat(id, "' was previously removed. "), d);
+        }
+        else {
+            this.warn("Node with id '".concat(id, "' not found. "), d);
+        }
+    };
+    Replayer.prototype.warnCanvasMutationFailed = function (d, error) {
+        this.warn("Has error on canvas update", error, 'canvas mutation:', d);
+    };
+    Replayer.prototype.debugNodeNotFound = function (d, id) {
+        if (this.treeIndex.idRemoved(id)) {
+            this.debug(REPLAY_CONSOLE_PREFIX, "Node with id '".concat(id, "' was previously removed. "), d);
+        }
+        else {
+            this.debug(REPLAY_CONSOLE_PREFIX, "Node with id '".concat(id, "' not found. "), d);
+        }
+    };
+    Replayer.prototype.warn = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (!this.config.showWarning) {
+            return;
+        }
+        console.warn.apply(console, __spreadArray([REPLAY_CONSOLE_PREFIX], __read(args), false));
+    };
+    Replayer.prototype.debug = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (!this.config.showDebug) {
+            return;
+        }
+        console.log.apply(console, __spreadArray([REPLAY_CONSOLE_PREFIX], __read(args), false));
+    };
+    return Replayer;
+}());
+
+exports.Replayer = Replayer;