@highlight-run/rrweb 1.2.0 → 2.0.1

package/es/rrweb/packages/rrweb/src/replay/virtual-styles.js

@@ -0,0 +1,121 @@
+import { __spreadArray, __read } from '../../ext/tslib/tslib.es6.js';
+
+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) {
+    }
+}
+
+export { StyleRuleType, applyVirtualStyleRulesToNode, getNestedRule, getPositionsAndIndex, storeCSSRules };

package/es/rrweb/packages/rrweb/src/types.js

@@ -0,0 +1,75 @@
+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 = {}));
+
+export { CanvasContext, EventType, IncrementalSource, MediaInteractions, MouseInteractions, ReplayerEvents };

package/es/rrweb/packages/rrweb/src/utils.js

@@ -0,0 +1,509 @@
+import { __values } from '../ext/tslib/tslib.es6.js';
+import { IncrementalSource } from './types.js';
+import { IGNORED_NODE, isShadowRoot, NodeType } from '../../rrweb-snapshot/es/rrweb-snapshot.js';
+
+function on(type, fn, target) {
+    if (target === void 0) { target = document; }
+    var options = { capture: true, passive: true };
+    target.addEventListener(type, fn, options);
+    return function () { return target.removeEventListener(type, fn, options); };
+}
+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 throttle(func, wait, options) {
+    if (options === void 0) { options = {}; }
+    var timeout = null;
+    var previous = 0;
+    return function (arg) {
+        var now = Date.now();
+        if (!previous && options.leading === false) {
+            previous = now;
+        }
+        var remaining = wait - (now - previous);
+        var context = this;
+        var args = arguments;
+        if (remaining <= 0 || remaining > wait) {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = null;
+            }
+            previous = now;
+            func.apply(context, args);
+        }
+        else if (!timeout && options.trailing !== false) {
+            timeout = setTimeout(function () {
+                previous = options.leading === false ? 0 : Date.now();
+                timeout = null;
+                func.apply(context, args);
+            }, remaining);
+        }
+    };
+}
+function hookSetter(target, key, d, isRevoked, win) {
+    if (win === void 0) { win = window; }
+    var original = win.Object.getOwnPropertyDescriptor(target, key);
+    win.Object.defineProperty(target, key, isRevoked
+        ? d
+        : {
+            set: function (value) {
+                var _this = this;
+                setTimeout(function () {
+                    d.set.call(_this, value);
+                }, 0);
+                if (original && original.set) {
+                    original.set.call(this, value);
+                }
+            },
+        });
+    return function () { return hookSetter(target, key, original || {}, true); };
+}
+function patch(source, name, replacement) {
+    try {
+        if (!(name in source)) {
+            return function () { };
+        }
+        var original_1 = source[name];
+        var wrapped = replacement(original_1);
+        if (typeof wrapped === 'function') {
+            wrapped.prototype = wrapped.prototype || {};
+            Object.defineProperties(wrapped, {
+                __rrweb_original__: {
+                    enumerable: false,
+                    value: original_1,
+                },
+            });
+        }
+        source[name] = wrapped;
+        return function () {
+            source[name] = original_1;
+        };
+    }
+    catch (_a) {
+        return function () { };
+    }
+}
+function getWindowHeight() {
+    return (window.innerHeight ||
+        (document.documentElement && document.documentElement.clientHeight) ||
+        (document.body && document.body.clientHeight));
+}
+function getWindowWidth() {
+    return (window.innerWidth ||
+        (document.documentElement && document.documentElement.clientWidth) ||
+        (document.body && document.body.clientWidth));
+}
+var isCanvasNode = function (node) {
+    try {
+        if (node instanceof HTMLElement) {
+            return node.tagName === 'CANVAS';
+        }
+    }
+    catch (_a) {
+        return false;
+    }
+    return false;
+};
+function isBlocked(node, blockClass) {
+    if (!node) {
+        return false;
+    }
+    if (node.nodeType === node.ELEMENT_NODE) {
+        var needBlock_1 = false;
+        if (typeof blockClass === 'string') {
+            if (node.closest !== undefined) {
+                return node.closest('.' + blockClass) !== null;
+            }
+            else {
+                needBlock_1 = node.classList.contains(blockClass);
+            }
+        }
+        else {
+            node.classList.forEach(function (className) {
+                if (blockClass.test(className)) {
+                    needBlock_1 = true;
+                }
+            });
+        }
+        return needBlock_1 || isBlocked(node.parentNode, blockClass);
+    }
+    if (node.nodeType === node.TEXT_NODE) {
+        return isBlocked(node.parentNode, blockClass);
+    }
+    return isBlocked(node.parentNode, blockClass);
+}
+function isIgnored(n) {
+    if ('__sn' in n) {
+        return n.__sn.id === IGNORED_NODE;
+    }
+    return false;
+}
+function isAncestorRemoved(target, mirror) {
+    if (isShadowRoot(target)) {
+        return false;
+    }
+    var id = mirror.getId(target);
+    if (!mirror.has(id)) {
+        return true;
+    }
+    if (target.parentNode &&
+        target.parentNode.nodeType === target.DOCUMENT_NODE) {
+        return false;
+    }
+    if (!target.parentNode) {
+        return true;
+    }
+    return isAncestorRemoved(target.parentNode, mirror);
+}
+function isTouchEvent(event) {
+    return Boolean(event.changedTouches);
+}
+function polyfill(win) {
+    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);
+}
+
+export { TreeIndex, _mirror, createMirror, getBaseDimension, getWindowHeight, getWindowWidth, hasShadowRoot, hookSetter, isAncestorRemoved, isBlocked, isCanvasNode, isIframeINode, isIgnored, isTouchEvent, iterateResolveTree, on, patch, polyfill, queueToResolveTrees, throttle };