@highlight-run/rrweb 1.2.0 → 2.0.1

package/dist/replay/rrweb-replay-unpack.js

@@ -0,0 +1,4626 @@
+var rrwebReplay = (function (exports) {
+    'use strict';
+
+    /*! *****************************************************************************
+    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$2(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$2(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$2(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$1 = 0; i$1 < chars.length; i$1++) {
+        lookup[chars.charCodeAt(i$1)] = i$1;
+    }
+    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;
+    }());
+
+    // DEFLATE is a complex format; to read this code, you should probably check the RFC first:
+
+    // aliases for shorter compressed code (most minifers don't do this)
+    var u8 = Uint8Array, u16 = Uint16Array, u32 = Uint32Array;
+    // fixed length extra bits
+    var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]);
+    // fixed distance extra bits
+    // see fleb note
+    var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]);
+    // code length index map
+    var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+    // get base, reverse index map from extra bits
+    var freb = function (eb, start) {
+        var b = new u16(31);
+        for (var i = 0; i < 31; ++i) {
+            b[i] = start += 1 << eb[i - 1];
+        }
+        // numbers here are at max 18 bits
+        var r = new u32(b[30]);
+        for (var i = 1; i < 30; ++i) {
+            for (var j = b[i]; j < b[i + 1]; ++j) {
+                r[j] = ((j - b[i]) << 5) | i;
+            }
+        }
+        return [b, r];
+    };
+    var _a = freb(fleb, 2), fl = _a[0], revfl = _a[1];
+    // we can ignore the fact that the other numbers are wrong; they never happen anyway
+    fl[28] = 258, revfl[258] = 28;
+    var _b = freb(fdeb, 0), fd = _b[0];
+    // map of value to reverse (assuming 16 bits)
+    var rev = new u16(32768);
+    for (var i = 0; i < 32768; ++i) {
+        // reverse table algorithm from SO
+        var x = ((i & 0xAAAA) >>> 1) | ((i & 0x5555) << 1);
+        x = ((x & 0xCCCC) >>> 2) | ((x & 0x3333) << 2);
+        x = ((x & 0xF0F0) >>> 4) | ((x & 0x0F0F) << 4);
+        rev[i] = (((x & 0xFF00) >>> 8) | ((x & 0x00FF) << 8)) >>> 1;
+    }
+    // create huffman tree from u8 "map": index -> code length for code index
+    // mb (max bits) must be at most 15
+    // TODO: optimize/split up?
+    var hMap = (function (cd, mb, r) {
+        var s = cd.length;
+        // index
+        var i = 0;
+        // u16 "map": index -> # of codes with bit length = index
+        var l = new u16(mb);
+        // length of cd must be 288 (total # of codes)
+        for (; i < s; ++i)
+            ++l[cd[i] - 1];
+        // u16 "map": index -> minimum code for bit length = index
+        var le = new u16(mb);
+        for (i = 0; i < mb; ++i) {
+            le[i] = (le[i - 1] + l[i - 1]) << 1;
+        }
+        var co;
+        if (r) {
+            // u16 "map": index -> number of actual bits, symbol for code
+            co = new u16(1 << mb);
+            // bits to remove for reverser
+            var rvb = 15 - mb;
+            for (i = 0; i < s; ++i) {
+                // ignore 0 lengths
+                if (cd[i]) {
+                    // num encoding both symbol and bits read
+                    var sv = (i << 4) | cd[i];
+                    // free bits
+                    var r_1 = mb - cd[i];
+                    // start value
+                    var v = le[cd[i] - 1]++ << r_1;
+                    // m is end value
+                    for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {
+                        // every 16 bit value starting with the code yields the same result
+                        co[rev[v] >>> rvb] = sv;
+                    }
+                }
+            }
+        }
+        else {
+            co = new u16(s);
+            for (i = 0; i < s; ++i)
+                co[i] = rev[le[cd[i] - 1]++] >>> (15 - cd[i]);
+        }
+        return co;
+    });
+    // fixed length tree
+    var flt = new u8(288);
+    for (var i = 0; i < 144; ++i)
+        flt[i] = 8;
+    for (var i = 144; i < 256; ++i)
+        flt[i] = 9;
+    for (var i = 256; i < 280; ++i)
+        flt[i] = 7;
+    for (var i = 280; i < 288; ++i)
+        flt[i] = 8;
+    // fixed distance tree
+    var fdt = new u8(32);
+    for (var i = 0; i < 32; ++i)
+        fdt[i] = 5;
+    // fixed length map
+    var flrm = /*#__PURE__*/ hMap(flt, 9, 1);
+    // fixed distance map
+    var fdrm = /*#__PURE__*/ hMap(fdt, 5, 1);
+    // find max of array
+    var max = function (a) {
+        var m = a[0];
+        for (var i = 1; i < a.length; ++i) {
+            if (a[i] > m)
+                m = a[i];
+        }
+        return m;
+    };
+    // read d, starting at bit p and mask with m
+    var bits = function (d, p, m) {
+        var o = (p / 8) >> 0;
+        return ((d[o] | (d[o + 1] << 8)) >>> (p & 7)) & m;
+    };
+    // read d, starting at bit p continuing for at least 16 bits
+    var bits16 = function (d, p) {
+        var o = (p / 8) >> 0;
+        return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >>> (p & 7));
+    };
+    // get end of byte
+    var shft = function (p) { return ((p / 8) >> 0) + (p & 7 && 1); };
+    // typed array slice - allows garbage collector to free original reference,
+    // while being more compatible than .slice
+    var slc = function (v, s, e) {
+        if (s == null || s < 0)
+            s = 0;
+        if (e == null || e > v.length)
+            e = v.length;
+        // can't use .constructor in case user-supplied
+        var n = new (v instanceof u16 ? u16 : v instanceof u32 ? u32 : u8)(e - s);
+        n.set(v.subarray(s, e));
+        return n;
+    };
+    // expands raw DEFLATE data
+    var inflt = function (dat, buf, st) {
+        // source length
+        var sl = dat.length;
+        // have to estimate size
+        var noBuf = !buf || st;
+        // no state
+        var noSt = !st || st.i;
+        if (!st)
+            st = {};
+        // Assumes roughly 33% compression ratio average
+        if (!buf)
+            buf = new u8(sl * 3);
+        // ensure buffer can fit at least l elements
+        var cbuf = function (l) {
+            var bl = buf.length;
+            // need to increase size to fit
+            if (l > bl) {
+                // Double or set to necessary, whichever is greater
+                var nbuf = new u8(Math.max(bl * 2, l));
+                nbuf.set(buf);
+                buf = nbuf;
+            }
+        };
+        //  last chunk         bitpos           bytes
+        var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+        // total bits
+        var tbts = sl * 8;
+        do {
+            if (!lm) {
+                // BFINAL - this is only 1 when last chunk is next
+                st.f = final = bits(dat, pos, 1);
+                // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman
+                var type = bits(dat, pos + 1, 3);
+                pos += 3;
+                if (!type) {
+                    // go to end of byte boundary
+                    var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l;
+                    if (t > sl) {
+                        if (noSt)
+                            throw 'unexpected EOF';
+                        break;
+                    }
+                    // ensure size
+                    if (noBuf)
+                        cbuf(bt + l);
+                    // Copy over uncompressed data
+                    buf.set(dat.subarray(s, t), bt);
+                    // Get new bitpos, update byte count
+                    st.b = bt += l, st.p = pos = t * 8;
+                    continue;
+                }
+                else if (type == 1)
+                    lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+                else if (type == 2) {
+                    //  literal                            lengths
+                    var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+                    var tl = hLit + bits(dat, pos + 5, 31) + 1;
+                    pos += 14;
+                    // length+distance tree
+                    var ldt = new u8(tl);
+                    // code length tree
+                    var clt = new u8(19);
+                    for (var i = 0; i < hcLen; ++i) {
+                        // use index map to get real code
+                        clt[clim[i]] = bits(dat, pos + i * 3, 7);
+                    }
+                    pos += hcLen * 3;
+                    // code lengths bits
+                    var clb = max(clt), clbmsk = (1 << clb) - 1;
+                    if (!noSt && pos + tl * (clb + 7) > tbts)
+                        break;
+                    // code lengths map
+                    var clm = hMap(clt, clb, 1);
+                    for (var i = 0; i < tl;) {
+                        var r = clm[bits(dat, pos, clbmsk)];
+                        // bits read
+                        pos += r & 15;
+                        // symbol
+                        var s = r >>> 4;
+                        // code length to copy
+                        if (s < 16) {
+                            ldt[i++] = s;
+                        }
+                        else {
+                            //  copy   count
+                            var c = 0, n = 0;
+                            if (s == 16)
+                                n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+                            else if (s == 17)
+                                n = 3 + bits(dat, pos, 7), pos += 3;
+                            else if (s == 18)
+                                n = 11 + bits(dat, pos, 127), pos += 7;
+                            while (n--)
+                                ldt[i++] = c;
+                        }
+                    }
+                    //    length tree                 distance tree
+                    var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+                    // max length bits
+                    lbt = max(lt);
+                    // max dist bits
+                    dbt = max(dt);
+                    lm = hMap(lt, lbt, 1);
+                    dm = hMap(dt, dbt, 1);
+                }
+                else
+                    throw 'invalid block type';
+                if (pos > tbts)
+                    throw 'unexpected EOF';
+            }
+            // Make sure the buffer can hold this + the largest possible addition
+            // Maximum chunk size (practically, theoretically infinite) is 2^17;
+            if (noBuf)
+                cbuf(bt + 131072);
+            var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+            var mxa = lbt + dbt + 18;
+            while (noSt || pos + mxa < tbts) {
+                // bits read, code
+                var c = lm[bits16(dat, pos) & lms], sym = c >>> 4;
+                pos += c & 15;
+                if (pos > tbts)
+                    throw 'unexpected EOF';
+                if (!c)
+                    throw 'invalid length/literal';
+                if (sym < 256)
+                    buf[bt++] = sym;
+                else if (sym == 256) {
+                    lm = null;
+                    break;
+                }
+                else {
+                    var add = sym - 254;
+                    // no extra bits needed if less
+                    if (sym > 264) {
+                        // index
+                        var i = sym - 257, b = fleb[i];
+                        add = bits(dat, pos, (1 << b) - 1) + fl[i];
+                        pos += b;
+                    }
+                    // dist
+                    var d = dm[bits16(dat, pos) & dms], dsym = d >>> 4;
+                    if (!d)
+                        throw 'invalid distance';
+                    pos += d & 15;
+                    var dt = fd[dsym];
+                    if (dsym > 3) {
+                        var b = fdeb[dsym];
+                        dt += bits16(dat, pos) & ((1 << b) - 1), pos += b;
+                    }
+                    if (pos > tbts)
+                        throw 'unexpected EOF';
+                    if (noBuf)
+                        cbuf(bt + 131072);
+                    var end = bt + add;
+                    for (; bt < end; bt += 4) {
+                        buf[bt] = buf[bt - dt];
+                        buf[bt + 1] = buf[bt + 1 - dt];
+                        buf[bt + 2] = buf[bt + 2 - dt];
+                        buf[bt + 3] = buf[bt + 3 - dt];
+                    }
+                    bt = end;
+                }
+            }
+            st.l = lm, st.p = pos, st.b = bt;
+            if (lm)
+                final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+        } while (!final);
+        return bt == buf.length ? buf : slc(buf, 0, bt);
+    };
+    // zlib valid
+    var zlv = function (d) {
+        if ((d[0] & 15) != 8 || (d[0] >>> 4) > 7 || ((d[0] << 8 | d[1]) % 31))
+            throw 'invalid zlib data';
+        if (d[1] & 32)
+            throw 'invalid zlib data: preset dictionaries not supported';
+    };
+    /**
+     * Expands Zlib data
+     * @param data The data to decompress
+     * @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.
+     * @returns The decompressed version of the data
+     */
+    function unzlibSync(data, out) {
+        return inflt((zlv(data), data.subarray(2, -4)), out);
+    }
+    /**
+     * Converts a string into a Uint8Array for use with compression/decompression methods
+     * @param str The string to encode
+     * @param latin1 Whether or not to interpret the data as Latin-1. This should
+     *               not need to be true unless decoding a binary string.
+     * @returns The string encoded in UTF-8/Latin-1 binary
+     */
+    function strToU8(str, latin1) {
+        var l = str.length;
+        if (!latin1 && typeof TextEncoder != 'undefined')
+            return new TextEncoder().encode(str);
+        var ar = new u8(str.length + (str.length >>> 1));
+        var ai = 0;
+        var w = function (v) { ar[ai++] = v; };
+        for (var i = 0; i < l; ++i) {
+            if (ai + 5 > ar.length) {
+                var n = new u8(ai + 8 + ((l - i) << 1));
+                n.set(ar);
+                ar = n;
+            }
+            var c = str.charCodeAt(i);
+            if (c < 128 || latin1)
+                w(c);
+            else if (c < 2048)
+                w(192 | (c >>> 6)), w(128 | (c & 63));
+            else if (c > 55295 && c < 57344)
+                c = 65536 + (c & 1023 << 10) | (str.charCodeAt(++i) & 1023),
+                    w(240 | (c >>> 18)), w(128 | ((c >>> 12) & 63)), w(128 | ((c >>> 6) & 63)), w(128 | (c & 63));
+            else
+                w(224 | (c >>> 12)), w(128 | ((c >>> 6) & 63)), w(128 | (c & 63));
+        }
+        return slc(ar, 0, ai);
+    }
+    /**
+     * Converts a Uint8Array to a string
+     * @param dat The data to decode to string
+     * @param latin1 Whether or not to interpret the data as Latin-1. This should
+     *               not need to be true unless encoding to binary string.
+     * @returns The original UTF-8/Latin-1 string
+     */
+    function strFromU8(dat, latin1) {
+        var r = '';
+        if (!latin1 && typeof TextDecoder != 'undefined')
+            return new TextDecoder().decode(dat);
+        for (var i = 0; i < dat.length;) {
+            var c = dat[i++];
+            if (c < 128 || latin1)
+                r += String.fromCharCode(c);
+            else if (c < 224)
+                r += String.fromCharCode((c & 31) << 6 | (dat[i++] & 63));
+            else if (c < 240)
+                r += String.fromCharCode((c & 15) << 12 | (dat[i++] & 63) << 6 | (dat[i++] & 63));
+            else
+                c = ((c & 15) << 18 | (dat[i++] & 63) << 12 | (dat[i++] & 63) << 6 | (dat[i++] & 63)) - 65536,
+                    r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023));
+        }
+        return r;
+    }
+
+    var MARK = 'v1';
+
+    var unpack = function (raw) {
+        if (typeof raw !== 'string') {
+            return raw;
+        }
+        try {
+            var e = JSON.parse(raw);
+            if (e.timestamp) {
+                return e;
+            }
+        }
+        catch (error) {
+        }
+        try {
+            var e = JSON.parse(strFromU8(unzlibSync(strToU8(raw, true))));
+            if (e.v === MARK) {
+                return e;
+            }
+            throw new Error("These events were packed with packer ".concat(e.v, " which is incompatible with current packer ").concat(MARK, "."));
+        }
+        catch (error) {
+            console.error(error);
+            throw new Error('Unknown data format.');
+        }
+    };
+
+    exports.Replayer = Replayer;
+    exports.unpack = unpack;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+    return exports;
+
+}({}));